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

README.md

@@ -5,22 +5,29 @@
 ### 입력
 - [x] "게임에 참여할 사람의 이름을 입력하세요.(쉼표 기준으로 분리) " 를 출력한다.
 - [x] 게임에 참여하는 참가자의 이름을 쉼표 기준으로 나누는 문자열을 하나 입력받는다.
+- [x] 참가자 별로 베팅할 금액을 입력
 - [x] 게임을 계속 진행할 지 결정하는 (y/n) 는 y, n를 입력한다.
 
 ### 입력 예외
 
 - [x] 이름은 쉼표 기준으로 분리되어 1개 이상이어야 한다.
 - [x] 이름은 영어로 2~10자 사이여야 한다.
-- [x] 이름은 영어로만 엊루이한야 져어루다한야. 
+- [x] 이름은 영어로만 이루어져야 한다.
 - [x] 이름은 소문자 기준으로 중복되지 않는다.
+- [x] 베팅할 금액은 10 이상의 양수여야 한다.
 - [x] 게임을 계속 진행할 지 결정하는 y, n만 입력할 수 있다.
 
 ### 기능
 
 1. 입력 처리
 
-- [x] 입력받은 문자열을 ‘,’를 기준으로 파싱한다.
-- [x] 파싱한 이름을 검증한다.
+   1-1. 참가자 이름 입력
+   - [x] 입력받은 문자열을 ‘,’를 기준으로 파싱한다.
+   - [x] 파싱한 이름을 검증한다.
+
+   1-2. 베팅 금액 입력
+   - [x] 참가자 별로 베팅할 금액을 입력받는다.
+   - [x] 베팅한 금액을 검증한다.
 
 
 2. 게임 진행
@@ -37,11 +44,14 @@
 
 3. 결과 처리
 
-- [X] 덱은 한 덱(52장)으로 고정한다(이때 하드코딩하지 않는다)
 - [x] 딜러와 각 참가자들의 카드 합을 구한다.
-- [x] 참가자 승 : 딜러보다 합이 21에 더 가까운 경우 or 딜러가 버스트인 경우(참가자 버스트 X)
-- [x] 참가자 무승부: 참가자와 딜러의 합이 같음(버스트 X)
-- [x] 참가자 패 : 참가자 버스트 or 딜러보다 합이 적음(딜러가 버스트 X)
+- [x] 딜러와 참가자 수익 계산 초기값은 '0'으로 수익, 손해는 이 값을 기준으로 계산한다.
+- [x] 처음 두 장의 카드 합이 21이면 블랙잭으로, 베팅 금액의 1.5배를 딜러에게 받는다.
+- [x] 딜러와 플레이어가 모두 동시에 블랙잭인 경우 플레이어는 베팅한 금액을 돌려받는다.(수익: 0)
+- [x] 카드를 추가로 뽑아 21을 초과할 경우 베팅 금액을 모두 잃게 된다. (수익: -베팅 금액)
+- [x] 딜러가 21을 초과하면 그 시점까지 남아 있던 플레이어들은 가지고 있는 패에 상관 없이 승리해 베팅 금액을 받는다. (수익: 베팅 금액)
+- [x] 딜러가 21을 초과하더라도 플레이어가 21을 초과해 이미 베팅 금액을 잃었다면 베팅 금액을 받지 않는다. (수익: -베팅 금액)
+- [x] 딜러가 21을 초과할 때 플레이어가 이미 블랙잭으로 1.5배를 받았다면 추가로 금액을 받지 않는다.
 
 ### 출력
 
@@ -51,4 +61,4 @@
 - [x] 참가자가 추가로 받은 카드들을“ [참가자]카드: 7클로버, K스페이드 ” 의 형태로 출력한다.
 - [x] 딜러가 받은 추가 카드를 “딜러는 16이하라 한장의 카드를 더 받았습니다.” 의 형태로 출력한다.
 - [x] 딜러, 참가자들의 카드 목록과 카드 합 결과를 “딜러카드: 3다이아몬드, 9클로버, 8다이아몬드 - 결과: 20” 의 형태로 출력한다.
-- [x] 딜러, 참가자들의 최종 승패를 “## 최종 승패 딜러: 1승 1패 [참가자]: 승 [참가자]: 패” 의 형태로 출력한다.
+- [x] 딜러, 참가자들의 수익을 ## 최종 수익 딜러 : xxxx [참가자]: xxxx [참가자]: xxxx” 의 형태로 출력한다.

src/main/java/Application.java

@@ -3,6 +3,7 @@
 import view.OutputView;
 
 public class Application {
+
     public static void main(String[] args) {
         InputView inputView = new InputView();
         OutputView outputView = new OutputView();

src/main/java/controller/BlackJackController.java

@@ -1,25 +1,25 @@
 package controller;
 
-import static util.Constants.COMMA_DELIMITER;
-import static util.Constants.DEALER_NAME;
-import static util.Constants.DEFAULT_CARD_SET;
-import static util.Constants.HIT;
-import static util.Constants.STAND;
-
+import domain.betting.Betting;
+import domain.betting.BettingAmount;
+import domain.card.GameCards;
 import domain.game.GamblersGameResult;
 import domain.game.Game;
+import domain.player.Dealer;
 import domain.player.Gambler;
-import dto.AgreementRequestDto;
-import dto.DealerResultDto;
-import dto.ParticipantHandResponseDto;
-import dto.ParticipantsGameInfoDto;
-import dto.ParticipantsHandResponseDto;
+import view.requestDto.AgreementRequestDto;
+import view.requestDto.BettingAmountRequestDto;
+import view.responseDto.DealerResultDto;
+import view.responseDto.ParticipantHandResponseDto;
+import view.responseDto.ParticipantsGameInfoDto;
+import view.responseDto.ParticipantsHandResponseDto;
 import java.util.List;
-import util.Parser;
+import java.util.Map;
 import view.InputView;
 import view.OutputView;
 
 public class BlackJackController {
+
     private final InputView inputView;
     private final OutputView outputView;
 
@@ -30,74 +30,82 @@ public BlackJackController(InputView inputView, OutputView outputView) {
 
     public void run() {
         List<String> names = inputGamblersInfo();
-        Game game = initializeGame(names);
+        Map<String, BettingAmount> gamblerNameAndBettingInfo = betByName(names);
+        Game game = initializeGame(gamblerNameAndBettingInfo);
 
         playGame(game);
         checkDealerHand(game);
 
         printParticipantsResult(game);
 
-        determineFinalGameResult(game.getResult());
+        determineFinalGameProfit(game.getResult());
     }
 
     private List<String> inputGamblersInfo() {
-        String name = inputView.askGamblerNames().name();
-        return Parser.parse(name, COMMA_DELIMITER);
+        return inputView.askGamblerNames().names();
     }
 
-    private Game initializeGame(List<String> names) {
-        Game game = new Game(DEALER_NAME, names, DEFAULT_CARD_SET);
+    private Map<String, BettingAmount> betByName(List<String> names) {
+        Betting betting = new Betting(names);
+        for (String name : names) {
+            BettingAmountRequestDto bettingAmountRequestDto = inputView.askBettingAmount(name);
+            betting.betBettingAmount(name,
+                    new BettingAmount(bettingAmountRequestDto.getBettingAmount()));
+        }
+        return betting.getBettingAmounts();
+    }
 
-        outputView.printInitialDeal(names);
+    private Game initializeGame(Map<String, BettingAmount> gamblerNameAndBettingInfo) {
+        Game game = new Game(Dealer.DEALER_NAME, gamblerNameAndBettingInfo,
+                GameCards.DEFAULT_CARD_SET);
+
+        outputView.printInitialDeal(gamblerNameAndBettingInfo.keySet().stream().toList());
         game.initializeGame();
         outputView.printParticipantsInfo(
-                new ParticipantsHandResponseDto(game.getInitialParticipantsHandInfo())
-        );
-
+                new ParticipantsHandResponseDto(game.getInitialParticipantsHandInfo()));
         return game;
     }
 
     private void playGame(Game game) {
         List<Gambler> gamblers = game.getGamblersList();
-        for(Gambler gambler : gamblers) {
+        for (Gambler gambler : gamblers) {
+            if (gambler.isBlackJack()) {
+                outputView.printBlackJackMessage(gambler.getName());
+                continue;
+            }
             playTurn(game, gambler);
         }
     }
 
     private void playTurn(Game game, Gambler gambler) {
-        while(!gambler.isBust()) {
+        while (!gambler.isBust()) {
             AgreementRequestDto agreementRequestDto = inputView.askHitOrStand(gambler.getName());
-            if (agreementRequestDto.agreement().equals(HIT)) {
-                gambler.addCard(game.pickCard());
+            if (agreementRequestDto.agreement().equals(InputView.HIT)) {
+                game.drawCardTo(gambler);
                 outputView.printParticipantInfo(
                         new ParticipantHandResponseDto(gambler.getName(), gambler.getHandInfo()));
             }
-            if (agreementRequestDto.agreement().equals(STAND)) {
+            if (agreementRequestDto.agreement().equals(InputView.STAND)) {
                 break;
             }
         }
     }
 
     private void checkDealerHand(Game game) {
         if (game.shouldDealerDraw()) {
-            outputView.printDealerCardIsUnder16();
-            game.addDealerCard();
+            outputView.printDealerCardIsBelowDrawThreshold();
+            game.drawCardTo(game.getDealer());
         }
     }
 
     private void printParticipantsResult(Game game) {
-        outputView.printParticipantsGameInfo(new ParticipantsGameInfoDto(
-                game.getParticipantGameInfos()
-        ));
+        outputView.printParticipantsGameInfo(
+                new ParticipantsGameInfoDto(game.getParticipantGameInfos()));
     }
 
-    private void determineFinalGameResult(GamblersGameResult gamblersGameResult) {
+    private void determineFinalGameProfit(GamblersGameResult gamblersGameResult) {
         outputView.printDealerResult(
-                new DealerResultDto(gamblersGameResult.countDealerWin(),
-                        gamblersGameResult.countDealerLose(),
-                        gamblersGameResult.countDealerDraw()));
-        outputView.printGamblerResult(
-                gamblersGameResult.getResultInfo()
-        );
+                new DealerResultDto(gamblersGameResult.getDealerProfit().getProfit()));
+        outputView.printGamblerResult(gamblersGameResult.getParticipantProfits());
     }
 }

src/main/java/domain/betting/Betting.java

@@ -0,0 +1,38 @@
+package domain.betting;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class Betting {
+
+    private final Map<String, BettingAmount> values = new LinkedHashMap<>();
+
+    public Betting(List<String> names) {
+        validateDuplicateNames(names);
+        for (String name : names) {
+            values.put(name, null);
+        }
+    }
+
+    public void betBettingAmount(String name, BettingAmount bettingAmount) {
+        values.put(name, bettingAmount);
+    }
+
+    public BettingAmount getBettingAmountByName(String name) {
+        return values.get(name);
+    }
+
+    public Map<String, BettingAmount> getBettingAmounts() {
+        return values;
+    }
+
+    public void validateDuplicateNames(List<String> names) {
+        List<String> distinctNamesCount = names.stream().
+                distinct().collect(Collectors.toList());
+        if (distinctNamesCount.size() != names.size()) {
+            throw new IllegalArgumentException("중복된 이름이 입력됩니다.");
+        }
+    }
+}

src/main/java/domain/betting/BettingAmount.java

@@ -0,0 +1,33 @@
+package domain.betting;
+
+import java.util.Objects;
+
+public class BettingAmount {
+
+    private final int bettingAmount;
+
+    public BettingAmount(int bettingAmount) {
+        this.bettingAmount = bettingAmount;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        BettingAmount that = (BettingAmount) o;
+        return bettingAmount == that.bettingAmount;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(bettingAmount);
+    }
+
+    public int getBettingAmount() {
+        return bettingAmount;
+    }
+}

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

@@ -1,6 +1,7 @@
 package domain.card;
 
 public class Card {
+
     private final CardScore score;
     private final CardKind kind;
 

src/main/java/domain/card/CardKind.java

@@ -5,7 +5,7 @@
 public enum CardKind {
     CLOVER("클로버"),
     HEART("하트"),
-    DIAMOND ("다이아몬드"),
+    DIAMOND("다이아몬드"),
     SPADES("스페이드");
 
     private final String kind;
@@ -18,7 +18,7 @@ public String getKind() {
         return kind;
     }
 
-    public static CardKind of(final String kind){
+    public static CardKind of(final String kind) {
         return Arrays.stream(values())
                 .filter(val -> val.kind.equals(kind))
                 .findFirst()

src/main/java/domain/card/CardScore.java

@@ -33,7 +33,7 @@ public String getScore() {
         return this.score;
     }
 
-    public static CardScore of(final String score){
+    public static CardScore of(final String score) {
         return Arrays.stream(values())
                 .filter(val -> val.score.equals(score))
                 .findFirst()

src/main/java/domain/card/GameCards.java

@@ -9,13 +9,16 @@
 
 public class GameCards {
 
+    public static final int DEFAULT_CARD_SET = 1;
+    public static final int DEFAULT_START_CARD_COUNT = 2;
+
     private List<Card> cards;
 
-    public GameCards(int amount) {
+    public GameCards(int DEFAULT_CARD_SET) {
         this.cards = Arrays.stream(CardKind.values())
                 .flatMap(cardKind -> Arrays.stream(CardScore.values())
                         .flatMap(cardScore ->
-                                IntStream.range(0, amount)
+                                IntStream.range(0, DEFAULT_CARD_SET)
                                         .mapToObj(card -> new Card(cardScore.getScore(),
                                                 cardKind.getKind()))
                         ))