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

README.md

@@ -5,30 +5,45 @@
 ### 기능 요구사항 체크리스트
 
 - [x] 게임에 참여할 사람의 이름을 쉼표(,) 기준으로 입력받아 분리한다.
+- [x] 사용자로부터 베팅 금액을 입력받는다.
 - [x] 0부터 51 사이의 난수를 생성해 무늬와 숫자가 매핑된 중복 없는 카드를 발급한다.
 - [x] 게임 시작 시 딜러와 플레이어에게 각각 2장씩 카드를 분배한다.
 - [x] 딜러의 초기 카드는 1장만 보여주고, 플레이어는 보유한 모든 카드를 보여준다.
 - [x] 플레이어는 카드 합계가 21을 넘지 않는 한 계속해서 카드를 더 받을 수 있다.
 - [x] 카드의 합을 계산할 때 K, Q, J는 10으로 계산하고, A는 11로 계산하고 21을 초과하면 1로 계산한다.
 - [x] 딜러는 처음에 받은 2장의 합계가 16 이하이면 무조건 1장의 카드를 추가로 받고, 17 이상이면 받지 않는다.
 - [x] 딜러와 플레이어의 턴이 모두 끝나면 각자의 최종 카드 목록과 점수를 출력한다.
-- [x] 최종 점수를 비교해 딜러와 각 플레이어의 승/패/무 결과를 계산하고 출력한다.
+- [x] 최종 점수와 딜러와 각 플레이어의 버스트/블랙잭/승패 결과를 통해 최종 수익을 계산해 출력한다.
 
 ### 주요 로직 요약
 
 - **카드 생성**
-    - `Card`에서 `0~51` 범위의 난수를 뽑아 카드 번호를 만든다.
+    - `DeckFactory`에서 `0~51` 범위의 카드를 생성해 'Deck' 에서 shuffle 로 카드를 무작위로 섞는다.
 - **카드 이름/점수 매핑**
     - 카드 번호를 `shape(무늬)`와 `number(랭크)`로 분리해 문자열 카드명으로 변환한다.
     - 점수는 `A=11`, `2~10=숫자값`, `J/Q/K=10`으로 계산한다.
 - **중복 없는 카드 보장**
-    - `DuplicationSet`에 이미 나온 번호를 저장해, 중복 번호가 나오면 다시 뽑는다.
+    - `Deck`에서 카드를 뽑을 때마다 List의 첫 번째 요소를 제거하며 반환
 - **버스트와 A 점수 보정**
     - 플레이어 점수가 21을 초과하면, 보유한 A 개수만큼 `11 -> 1` 보정(10점 차감)을 적용한다.
 - **게임 진행**
     - 시작 시 딜러/플레이어 모두 2장 배분
     - 플레이어는 입력(`y/n`)으로 추가 카드 선택
     - 딜러는 합계가 16 이하일 때 자동으로 추가 카드 드로우
-- **승패 계산**
-    - 버스트는 `-1` 처리 후 딜러와 각 플레이어 점수를 비교해 `승/패/무`를 기록한다.
-
+- **수익 계산**
+    - 플레이어의 카드가 21을 초과할 경우 베팅 금액을 모두 잃게 된다
+    - 처음 두 장의 카드 합이 21일 경우 블랙잭이 되면 베팅 금액의 1.5 배를 딜러에게 받는다.
+        - 딜러와 플레이어 모두 블랙잭인 경우 베팅 금액을 돌려받는다.
+    - 딜러가 21을 초과하면 남아 있던 플레이어들은 패에 상관 없이 베팅 금액을 받는다.
+
+### 최종 수익 계산
+
+| 상황                           | 결과  | 수익 배율 | 비고                |
+|:-----------------------------|:----|:-----:|:------------------|
+| **플레이어 버스트(Bust)**           | 패배  | -1.0  | 베팅 금액 상실          |
+| **플레이어 블랙잭 & 딜러 블랙잭 아님**     | 승리  | +1.5  | 베팅 금액의 1.5배 수익 발생 |
+| **플레이어 & 딜러 모두 블랙잭**         | 무승부 |   0   | 베팅 금액 돌려받음        |
+| **플레이어 21 이하 & 딜러 버스트**      | 승리  | +1.0  | 베팅 금액만큼 수익 발생     |
+| **둘 다 21 이하 (플레이어 점수 > 딜러)** | 승리  | +1.0  | 베팅 금액만큼 수익 발생     |
+| **둘 다 21 이하 (플레이어 점수 < 딜러)** | 패배  | -1.0  | 베팅 금액 상실          |
+| **둘 다 21 이하 (플레이어 점수 = 딜러)** | 무승부 |   0   | 베팅 금액 돌려받음        |

src/main/java/controller/BlackJackGame.java

@@ -1,24 +1,20 @@
 package controller;
 
-import domain.Card;
-import domain.Dealer;
-import domain.Deck;
-import domain.GameResult;
-import domain.Outcome;
-import domain.Participant;
-import domain.Player;
-import domain.Players;
-import dto.AllOutcomeDto;
+import domain.card.Deck;
+import domain.card.DeckFactory;
+import domain.participant.Dealer;
+import domain.participant.Money;
+import domain.participant.Player;
+import domain.participant.Players;
+import domain.result.Outcome;
 import dto.FinalScoreDto;
 import dto.InitialDto;
+import dto.MoneyDTO;
 import dto.ParticipantDto;
 import dto.ParticipantScoreDto;
 import dto.PlayerOutcomeDto;
 import java.util.ArrayList;
-import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import util.NameParser;
 import view.InputView;
@@ -34,46 +30,61 @@ public BlackJackGame(InputView inputView, ResultView resultView) {
     }
 
     public void run() {
-        Deck deck = createDeck();
+        Deck deck = DeckFactory.create();
         Dealer dealer = new Dealer();
-        Players players = NameParser.makeNameList(inputView.getParticipant());
+        Players players = setupPlayers();
+        playGame(deck, dealer, players);
+    }
+
+    private void playGame(Deck deck, Dealer dealer, Players players) {
         initialDraw(deck, dealer, players);
         printInitialStatus(dealer, players);
-        players.getPlayers().forEach(player -> drawPlayerTurn(deck, player));
+        if (dealer.isFirstBlackJack()) {
+            printResults(dealer, players);
+            return;
+        }
+        players.players().forEach(player -> drawPlayerTurn(deck, player));
         drawDealerTurn(deck, dealer);
+        printResults(dealer, players);
+    }
+
+    private void printResults(Dealer dealer, Players players) {
         printFinalScore(dealer, players);
-        printFinalWinner(dealer, players);
+        printFinalProfit(dealer, players);
     }
 
-    private Deck createDeck() {
-        List<Card> cards = IntStream.range(0, 52)
-                .mapToObj(Card::new)
-                .collect(Collectors.toList());
-        return new Deck(cards);
+    private Players setupPlayers() {
+        List<String> playerNames = NameParser.makeNameList(inputView.getParticipant());
+        List<Player> players = new ArrayList<>();
+        for (String name : playerNames) {
+            String money = inputView.getMoney(name);
+            players.add(new Player(name, new Money(money)));
+        }
+        return new Players(players);
     }
 
     private void initialDraw(Deck deck, Dealer dealer, Players players) {
         IntStream.range(0, 2).forEach(i -> {
             dealer.drawCard(deck.draw());
-            players.getPlayers().forEach(player -> player.drawCard(deck.draw()));
+            players.players().forEach(player -> player.drawCard(deck.draw()));
         });
     }
 
     private void printInitialStatus(Dealer dealer, Players players) {
-        ParticipantDto dealerDto = new ParticipantDto(dealer.getName(), getCardNames(dealer));
-        List<ParticipantDto> participantDtos = players.getPlayers().stream()
-                .map(player -> new ParticipantDto(player.getName(), getCardNames(player)))
-                .collect(Collectors.toList());
-        String joinedNames = players.getPlayers().stream()
-                .map(Player::getName)
-                .collect(Collectors.joining(", "));
-        resultView.printGameStart(new InitialDto(joinedNames, dealerDto, participantDtos));
+        ParticipantDto dealerDto = ParticipantDto.from(dealer);
+        List<ParticipantDto> participants =
+                players.players()
+                        .stream()
+                        .map(ParticipantDto::from)
+                        .toList();
+        String joinedNames = players.getJoinedNames();
+        resultView.printGameStart(new InitialDto(joinedNames, dealerDto, participants));
     }
 
     private void drawPlayerTurn(Deck deck, Player player) {
         while (player.canDraw() && inputView.getMoreCards(player.getName()).equals("y")) {
             player.drawCard(deck.draw());
-            resultView.printParticipantMoreCard(new ParticipantDto(player.getName(), getCardNames(player)));
+            resultView.printParticipantMoreCard(ParticipantDto.from(player));
         }
     }
 
@@ -84,39 +95,25 @@ private void drawDealerTurn(Deck deck, Dealer dealer) {
         }
     }
 
-    private void printFinalWinner(Dealer dealer, Players players) {
-        Map<Player, Outcome> playerResults = new LinkedHashMap<>();
-        List<PlayerOutcomeDto> outcomeDtos = new ArrayList<>();
-        for (Player player : players.getPlayers()) {
-            Outcome outcome = Outcome.decideWinner(player.getScore(), dealer.getScore());
-            playerResults.put(player, outcome);
-            outcomeDtos.add(new PlayerOutcomeDto(player.getName(), outcome.getName()));
-        }
-        GameResult gameResult = new GameResult(playerResults);
-        resultView.printWinner(new AllOutcomeDto(gameResult.getDealerResult(), outcomeDtos));
-    }
-
     private void printFinalScore(Dealer dealer, Players players) {
-        ParticipantScoreDto dealerScoreDto = createScoreDto(dealer);
-        List<ParticipantScoreDto> playerScoreDtos = players.getPlayers().stream()
-                .map(this::createScoreDto)
-                .collect(Collectors.toList());
+        ParticipantScoreDto dealerScoreDto = ParticipantScoreDto.from(dealer);
+        List<ParticipantScoreDto> playerScoreDtos =
+                players.players()
+                        .stream()
+                        .map(ParticipantScoreDto::from)
+                        .toList();
         resultView.printResult(new FinalScoreDto(dealerScoreDto, playerScoreDtos));
     }
 
-    private ParticipantScoreDto createScoreDto(Participant participant) {
-        return new ParticipantScoreDto(
-                participant.getName(),
-                getCardNames(participant),
-                participant.getScore().getGameScore()
-        );
-    }
-
-    private List<String> getCardNames(Participant participant) {
-        List<String> cardNames = new ArrayList<>();
-        for (Card card : participant.getHand().getCards()) {
-            cardNames.add(card.getCardName());
+    private void printFinalProfit(Dealer dealer, Players players) {
+        int dealerProfit = 0;
+        List<PlayerOutcomeDto> outcomeDtos = new ArrayList<>();
+        for (Player player : players.players()) {
+            Outcome outcome = Outcome.decideWinner(player, dealer);
+            Money playerProfit = player.getMoney().multiply(outcome.getRate());
+            dealerProfit -= playerProfit.getAmount();
+            outcomeDtos.add(PlayerOutcomeDto.of(player, playerProfit));
         }
-        return cardNames;
+        resultView.printScore(new MoneyDTO(String.valueOf(dealerProfit), outcomeDtos));
     }
-}
+}

src/main/java/domain/Card.java → src/main/java/domain/card/Card.java

@@ -1,12 +1,6 @@
-package domain;
-
-public class Card {
-    private final int card;
-
-    public Card(int card) {
-        this.card = card;
-    }
+package domain.card;
 
+public record Card(int card) {
     public String getCardName() {
         int shape = card / 13;
         int number = card % 13;
@@ -15,23 +9,16 @@ public String getCardName() {
 
     public int getScore() {
         int cardNumber = card % 13;
-
         if (1 <= cardNumber && cardNumber <= 9) {
             return cardNumber + 1;
         }
-
         if (cardNumber >= 10) {
             return 10;
         }
-
         return 11;
     }
 
     public boolean isAce() {
         return card % 13 == 0;
     }
-
-    public int getCard() {
-        return card;
-    }
-}
+}

src/main/java/domain/CardSuitMap.java → src/main/java/domain/card/CardSuitMap.java

@@ -1,4 +1,4 @@
-package domain;
+package domain.card;
 
 import java.util.Map;
 
@@ -26,6 +26,10 @@ public final class CardSuitMap {
             Map.entry(12, "K")
     );
 
+    private CardSuitMap() {
+
+    }
+
     public static String getSuit(int shape) {
         return SUIT_MAP.get(shape);
     }
@@ -34,3 +38,4 @@ public static String getRank(int number) {
         return RANK_MAP.get(number);
     }
 }
+

src/main/java/domain/Deck.java → src/main/java/domain/card/Deck.java

@@ -1,11 +1,9 @@
-package domain;
+package domain.card;
 
 import java.util.Collections;
 import java.util.List;
 
-public class Deck {
-    private final List<Card> cards;
-
+public record Deck(List<Card> cards) {
     public Deck(List<Card> cards) {
         this.cards = cards;
         shuffle();