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

README.md

@@ -9,12 +9,20 @@
 pobi,jason  
 ```  
 
+✅️ 카드 수령 여부 입력 뷰
+```text
+pobi의 배팅 금액은?
+10000
+```
+
+
 ---  
 
 ✅ 카드 수령 여부 입력 뷰
 
 ```text  
-pobi는 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)y  
+pobi는 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)
+y
 ```  
 
 # 출력
@@ -63,13 +71,13 @@ jason카드: 7클로버, K스페이드 - 결과: 17
 
 ---  
 
-✅ 최종 승패 출력 뷰
+✅ 최종 수익 출력 뷰
 
 ```text  
-## 최종 승패  
-딜러: 1승 1패  
-pobi: 승
-jason: 패  
+## 최종 수익  
+딜러: 10000
+pobi: 10000 
+jason: -20000 
 ```  
 
 # 핵심 기능
@@ -143,13 +151,15 @@ jason: 패
 
 ---
 
-✅ 최종 승패 계산 기능
-
-- 게임 참가자의 승패 여부를 계산한다.
+✅ 최종 수익 계산 기능
+- 딜러와 게임 참가자의 최종 수익을 계산한다.
 - 딜러가 버스트인 경우에는 아래의 규칙을 따른다.
-    - 버스트가 아닌 모든 참가자는 승이다.
-    - 버스트인 모든 참가자는 패다.
+    - 버스트가 아닌 모든 참가자는 배팅한 금액을 수익으로 가져간다.
+      - 만약 참가자가 블랙잭이면(처음 받은 카드 2장의 합이 21이면) 배팅한 금액의 1.5배를 수익으로 가져간다.
+    - 버스트인 모든 참가자는 배팅한 금액을 잃는다.
 - 딜러가 버스트가 아닌 경우에는 아래의 규칙을 따른다.
-    - 딜러의 점수보다 낮거나 버스트인 참가자들은 패다.
-    - 딜러의 점수와 같은 참가자들은 무다.
-    - 딜러의 점수보다 높음 참가자들은 승이다.
+    - 딜러의 점수보다 낮거나 버스트인 참가자들은 배팅한 금액만큼 잃는다.
+    - 딜러의 점수와 같은 참가자들은 수익이 0이다.
+    - 딜러의 점수보다 높음 참가자들은 배팅한 금액을 수익으로 가져간다.
+      - 만약 참가자가 블랙잭이면(처음 받은 카드 2장의 합이 21이면) 배팅한 금액의 1.5배를 수익으로 가져간다.
+

src/main/java/controller/BlackjackController.java

@@ -1,11 +1,14 @@
 package controller;
 
-import constant.HitOrStand;
+import domain.game.BlackjackGameManager;
+import domain.game.HitOrStand;
+import domain.participant.BetAmount;
+import domain.participant.PlayerName;
 import dto.BlackjackResultDto;
 import dto.BlackjackStatisticsDto;
 import dto.ParticipantDto;
+import java.util.ArrayList;
 import java.util.List;
-import domain.game.BlackjackGameManager;
 import util.Parser;
 import view.InputView;
 import view.OutputView;
@@ -34,7 +37,10 @@ public void start() {
     }
 
     private void initializeGame() {
-        inputPlayers();
+        List<PlayerName> playerNames = inputPlayerNames();
+        List<BetAmount> betAmounts = inputBetAmounts(playerNames);
+        blackjackGameManager.createParticipants(playerNames, betAmounts);
+
         blackjackGameManager.drawInitialCards();
 
         List<ParticipantDto> playerDtoList = blackjackGameManager.generatePlayerDtoList();
@@ -44,9 +50,22 @@ private void initializeGame() {
         outputView.printHandList(dealerDto, playerDtoList);
     }
 
-    private void inputPlayers() {
-        List<String> input = Parser.parseInput(inputView.inputPlayers());
-        blackjackGameManager.createPlayers(input);
+    private List<BetAmount> inputBetAmounts(List<PlayerName> playerNames) {
+        List<BetAmount> betAmounts = new ArrayList<>();
+        for (PlayerName playerName : playerNames) {
+            String betAmountInput = inputView.inputBetAmount(playerName.name());
+            betAmounts.add(new BetAmount(betAmountInput));
+        }
+        return betAmounts;
+    }
+
+    private List<PlayerName> inputPlayerNames() {
+        List<String> names = Parser.parseInput(inputView.inputPlayers());
+        List<PlayerName> playerNames = new ArrayList<>();
+        for (String name : names) {
+            playerNames.add(new PlayerName(name));
+        }
+        return playerNames;
     }
 
     private void inputHitOrStandOnPlayer() {
@@ -58,20 +77,23 @@ private void inputHitOrStandOnPlayer() {
 
     private void inputHitOrStand(String name, List<String> hand) {
         HitOrStand hitOrStand = HitOrStand.from(inputView.inputHitOrStand(name));
-        if (blackjackGameManager.isStand(hitOrStand)) {
+        if (hitOrStand.isStand()) {
             outputView.printlnHand(name, hand);
             return;
         }
 
-        drawCardOnPlayer(name, hitOrStand);
+        drawCardOnPlayer(name);
     }
 
-    private void drawCardOnPlayer(String name, HitOrStand hitOrStand) {
-        while (blackjackGameManager.isHit(hitOrStand)) {
+    private void drawCardOnPlayer(String name) {
+        do {
             ParticipantDto playerDto = blackjackGameManager.updatePlayer(name);
             outputView.printlnHand(name, playerDto.hand());
-            hitOrStand = HitOrStand.from(inputView.inputHitOrStand(name));
-        }
+        } while (canDrawContinue(name));
+    }
+
+    private boolean canDrawContinue(String name) {
+        return !blackjackGameManager.playerIsBust(name) && HitOrStand.from(inputView.inputHitOrStand(name)).isHit();
     }
 
     private void printBlackjackResult() {

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

@@ -9,14 +9,4 @@ public int getScore() {
     public boolean isAce() {
         return rank.isAce();
     }
-
-    @Override
-    public boolean equals(Object o) {
-        if (o == null || getClass() != o.getClass()) {
-            return false;
-        }
-        Card card = (Card) o;
-        return rank == card.rank && suit == card.suit;
-    }
-
 }

src/main/java/domain/card/CardMachine.java

@@ -33,11 +33,11 @@ private void setRanksAndSuits(List<Card> decks) {
 
     private void setSuits(List<Card> decks, Rank rank) {
         for (Suit suit : Suit.values()) {
-            addRepeatSix(decks, rank, suit);
+            addRepeatDeckCount(decks, rank, suit);
         }
     }
 
-    private void addRepeatSix(List<Card> decks, Rank rank, Suit suit) {
+    private void addRepeatDeckCount(List<Card> decks, Rank rank, Suit suit) {
         for (int i = 0; i < DECK_COUNT; i++) {
             decks.add(new Card(rank, suit));
         }

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

@@ -6,6 +6,8 @@
 public class Hand {
 
     private static final int BLACKJACK_SCORE = 21;
+    private static final int REDUCED_SCORE_FROM_ACE = 10;
+    private static final int INITIAL_CARD_COUNT = 2;
 
     private final List<Card> cards;
 
@@ -17,29 +19,49 @@ public void addCard(Card card) {
         cards.add(card);
     }
 
-    public int calculateScore() {
-        int score = cards.stream()
-            .map(Card::getScore)
-            .reduce(0, Integer::sum);
-        int aceCount = cards.stream()
-            .filter(Card::isAce)
-            .toList()
-            .size();
+    public int calculateTotalScore() {
+        int baseScore = calculateBaseScore();
+        int aceCount = calculateAceCount();
 
-        return calculateScoreWithBestAce(score, aceCount);
+        return calculateTotalScoreWithAceCalculation(baseScore, aceCount);
     }
 
-    private int calculateScoreWithBestAce(int score, int aceCount) {
+    private int calculateInitialScore() {
+        int baseScore = calculateInitialBaseScore();
+        int aceCount = calculateAceCount();
+
+        return calculateTotalScoreWithAceCalculation(baseScore, aceCount);
+    }
+
+    private Integer calculateBaseScore() {
+        return cards.stream()
+                .map(Card::getScore)
+                .reduce(0, Integer::sum);
+    }
+
+    private Integer calculateInitialBaseScore() {
+        return cards.subList(0, INITIAL_CARD_COUNT).stream()
+                .map(Card::getScore)
+                .reduce(0, Integer::sum);
+    }
+
+    private int calculateAceCount() {
+        return (int) cards.stream()
+                .filter(Card::isAce)
+                .count();
+    }
+
+    private int calculateTotalScoreWithAceCalculation(int score, int aceCount) {
         while (score > BLACKJACK_SCORE && aceCount > 0) {
-            score -= 10;
+            score -= REDUCED_SCORE_FROM_ACE;
             aceCount--;
         }
 
         return score;
     }
 
     public boolean isBust() {
-        return calculateScore() > BLACKJACK_SCORE;
+        return calculateTotalScore() > BLACKJACK_SCORE;
     }
 
     public Card getFirstCard() {
@@ -50,4 +72,8 @@ public List<Card> getCard() {
         return cards.stream()
                 .toList();
     }
+
+    public boolean isBlackjack() {
+        return calculateInitialScore() == BLACKJACK_SCORE;
+    }
 }

src/main/java/domain/card/Rank.java

@@ -24,15 +24,15 @@ public enum Rank {
         this.score = score;
     }
 
-    public boolean isAce() {
-        return this.equals(Rank.ACE);
-    }
-
     public String getRank() {
         return rank;
     }
 
     public int getScore() {
         return score;
     }
+
+    public boolean isAce() {
+        return this.equals(Rank.ACE);
+    }
 }