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

README.md

@@ -3,48 +3,54 @@
 ## 블랙잭 미션 기능 명세
 
 ### 입력
-- [x] "게임에 참여할 사람의 이름을 입력하세요.(쉼표 기준으로 분리) " 를 출력한다.
 - [x] 게임에 참여하는 참가자의 이름을 쉼표 기준으로 나누는 문자열을 하나 입력받는다.
+- [x] 참가자들에게 각각 베팅 금액을 입력받는다.
 - [x] 게임을 계속 진행할 지 결정하는 (y/n) 는 y, n를 입력한다.
 
-### 입력 예외
-
-- [x] 이름은 쉼표 기준으로 분리되어 1개 이상이어야 한다.
-- [x] 이름은 영어로 2~10자 사이여야 한다.
-- [x] 이름은 영어로만 엊루이한야 져어루다한야. 
-- [x] 이름은 소문자 기준으로 중복되지 않는다.
-- [x] 게임을 계속 진행할 지 결정하는 y, n만 입력할 수 있다.
-
 ### 기능
-
-1. 입력 처리
-
-- [x] 입력받은 문자열을 ‘,’를 기준으로 파싱한다.
-- [x] 파싱한 이름을 검증한다.
-
+1. 게임 세팅
+- [x] 한 명의 딜러가 존재한다.
+  - [x] 딜러는 "Dealer"라는 이름으로 고정된다.
+
+- [x] 여러 명의 참가자가 존재한다.
+  - [x] 참가자는 최소 1명 이상이다.
+  - [x] 참가자는 이름을 가진다. 
+    - [x] 이름은 2 ~ 10자 사이이다.
+    - [x] 이름은 알파벳으로 이루어져 있다.
+  - [x] 참가자는 베팅 금액을 갖는다.
+    - [x] 입력 금액은 양수여야 한다.
+    - [x] 입력 금액은 100억을 넘지 않는다.
+  - [x] 참가자들의 이름은 중복일 수 없다
 
 2. 게임 진행
-
-- [x] 딜러와 참가자들에게 각각 2 장의 카드를 랜덤하게 부여한다. 이때 딜러의 카드는 가장 처음 받은 카드 한 장만 보여준다.
-- [x] 각 참가자들별로 bust가 나기 전까지 카드를 더 받는 Hit(y) 또는 그만 받는 Stand(n)를 선택한다.
-- [x] ‘A에이스’는 현재 가지고 있는 카드의 합에 따라 자동으로 계산되어 적용된다.
-  - [x] 현재 가지고 있는 카드의 합 + 11의 값이 21 초과인 경우 1로 계산한다.
-  - [x] 현재 가지고 있는 카드의 합 + 11의 값이 21인 경우 11로 계산한다.
-  - [x] 현재 가지고 있는 카드의 합 + 11의 값이 21 미만이면 11로 계산한다.
-- [x] 딜러가 처음 받은 2장의 합계가 16이하면 반드시 1장의 카드를 추가로 받아야 하고, 17점 이상이면 추가로 받을 수 없다. (1장 초과 받지 않음)
-
-
-
-3. 결과 처리
-
-- [X] 덱은 한 덱(52장)으로 고정한다(이때 하드코딩하지 않는다)
+- [x] 딜러와 참가자는 손패(카드 목록)을 가질 수 있다.
+  - [x] 카드는 랜덤하게 부여된다.
+  - [x] 딜러와 참가자는 게임 시작 시 2장의 카드를 부여받는다.
+    - [x] 덱은 한 덱(52장)으로 고정한다
+  - [x] 카드는 점수를 가지고 있다.
+    - [x] 숫자 카드는 숫자만큼의 점수를 가진다.
+    - [x] ACE인 경우 1 또는 11의 값을 가진다
+    - [x] K, Q, J는 10점을 가진다.
+  - [x] 참가자들은 버스트나기 전까지 카드를 더 받는 Hit(y)할 수 있다.
+  - [x] 참가자들은 카드를 그만 받는 Stand(n)를 선택할 수 있다.
+    - [x] y/n 이외의 입력은 받을 수 없다
+  - [x] 딜러는 처음 2장의 합이 16이하면 1장의 카드를 추가로 받는다.
+
+3. 게임 점수 계산
 - [x] 딜러와 각 참가자들의 카드 합을 구한다.
+  - [x] ACE가 존재하지 않을 경우 모든 카드 점수를 합산한다.
+  - [x] ACE가 존재할 경우 11로 지정한 뒤 합산한 카드 점수가 21을 이상인 경우 1로 환산하여 계산한다
+
+  4. 게임 결과
 - [x] 참가자 승 : 딜러보다 합이 21에 더 가까운 경우 or 딜러가 버스트인 경우(참가자 버스트 X)
-- [x] 참가자 무승부: 참가자와 딜러의 합이 같음(버스트 X)
+  - [x] 참가자가 21인 경우 : 베팅 금액의 1.5배를 받는다
+  - [x] 참가자가 21이 아닌 경우 : 베팅 금액만큼 받는다
+- [x] 참가자 무승부: 참가자와 딜러의 합이 같음
+  - [x] 기존 베팅 금액을 그대로 돌려받는다.
 - [x] 참가자 패 : 참가자 버스트 or 딜러보다 합이 적음(딜러가 버스트 X)
+  - [x] 베팅 금액을 잃는다.
 
 ### 출력
-
 - [x] 참가자를 입력받은 후 “딜러와 [참가자 목록]에게 2장을 나누었습니다. ” 를 출력한다. 이때 참가자의 이름은 쉼표로 구분하여 출력한다.
 - [x] 딜러와 참가자들의 카드를 각각 쉼표로 구분하여 출력한다.
 - [x] 각 참가자의 게임 턴에 “[참가자]는 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)" 를 출력한다.

src/main/java/controller/BlackJackController.java

@@ -5,15 +5,22 @@
 import static util.Constants.HIT;
 import static util.Constants.STAND;
 
+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 domain.player.Gamblers;
+import domain.player.attribute.Hand;
+import domain.player.attribute.Money;
+import domain.player.attribute.Name;
+import dto.request.AgreementRequestDto;
+import dto.response.DealerResultDto;
+import dto.response.ParticipantHandResponseDto;
+import dto.response.ParticipantsGameInfoDto;
+import dto.response.ParticipantsHandResponseDto;
 import java.util.List;
+import java.util.stream.Collectors;
 import util.Parser;
 import view.input.InputView;
 import view.output.OutputView;
@@ -28,8 +35,11 @@ public BlackJackController(InputView inputView, OutputView outputView) {
     }
 
     public void run() {
-        List<String> names = inputGamblersInfo();
-        Game game = initializeGame(names);
+        Dealer dealer = makeDealer();
+        Gamblers gamblers = makeGambers();
+        GameCards gambeCards = new GameCards(1);
+
+        Game game = initializeGame(dealer, gamblers, gambeCards);
 
         playGame(game);
         checkDealerHand(game);
@@ -39,24 +49,42 @@ public void run() {
         determineFinalGameResult(game.getResult());
     }
 
-    private void determineFinalGameResult(GamblersGameResult gamblersGameResult) {
-        outputView.printDealerResult(
-                new DealerResultDto(gamblersGameResult.countDealerWin(),
-                        gamblersGameResult.countDealerLose(),
-                        gamblersGameResult.countDealerDraw()));
-        outputView.printGamblerResult(
-                gamblersGameResult.getResultInfo()
-        );
+    private Dealer makeDealer() {
+        Name dealerName = new Name(DEALER_NAME);
+        Hand dealerHand = new Hand();
+        Dealer dealer = new Dealer(dealerName, dealerHand);
+
+        return dealer;
+    }
+
+    private Gamblers makeGambers() {
+        List<Name> names = inputGamblersInfo()
+                .stream()
+                .map(Name::new)
+                .toList();
+
+        List<Gambler> gamblerList = names.stream()
+                .map(name -> {
+                    String betAmountInput = inputView.askGamblerBetAmount(name.getName())
+                            .betAmount();
+                    Hand hand = new Hand();
+                    Money betAmount = new Money(betAmountInput);
+
+                    return new Gambler(name, hand, betAmount);
+                })
+                .toList();
+        return new Gamblers(gamblerList);
     }
+
     private List<String> inputGamblersInfo() {
         String name = inputView.askGamblerNames().name();
         return Parser.parse(name, COMMA_DELIMITER);
     }
 
-    private Game initializeGame(List<String> names) {
-        Game game = new Game(DEALER_NAME, names, 1);
+    private Game initializeGame(Dealer dealer, Gamblers gamblers, GameCards cards) {
+        Game game = new Game(dealer, gamblers, cards);
 
-        outputView.printInitialDeal(names);
+        outputView.printInitialDeal(gamblers.getNames());
         game.initializeGame();
         outputView.printParticipantsInfo(
                 new ParticipantsHandResponseDto(game.getInitialParticipantsHandInfo())
@@ -98,4 +126,9 @@ private void printParticipantsResult(Game game) {
                 game.getParticipantGameInfos()
         ));
     }
+
+    private void determineFinalGameResult(GamblersGameResult gamblersGameResult) {
+        outputView.printDealerResult(new DealerResultDto(gamblersGameResult.getDealerResult()));
+        outputView.printGamblerResult(gamblersGameResult.getResultInfo());
+    }
 }

src/main/java/domain/game/GamblersGameResult.java

@@ -1,55 +1,44 @@
 package domain.game;
 
-import java.util.LinkedHashMap;
+import domain.player.Dealer;
+import domain.player.Gambler;
+import domain.player.Gamblers;
+import java.util.Collections;
 import java.util.Map;
 import java.util.stream.Collectors;
 
 public class GamblersGameResult {
 
-    private Map<String, GameResult> gamblersResult;
+    private Map<String, Long> gamblersResult;
 
-    public GamblersGameResult(int dealerScore, Map<String, Integer> gameResults) {
-        this.gamblersResult = gameResults.entrySet()
-                .stream()
-                .collect(Collectors.toMap(Map.Entry::getKey,
-                        entry -> GameResult.determine(
-                                dealerScore,
-                                entry.getValue()),
-                                (a, b) -> a, LinkedHashMap::new));
-    }
-
-    public GameResult getMatchResult(String name) {
-        return gamblersResult.get(name);
-    }
+    public GamblersGameResult(Dealer dealer, Gamblers gamblers) {
+        int dealerTotalScore = dealer.getTotalScore();
 
-    public int countDealerWin() {
-        return (int) gamblersResult.values()
+        this.gamblersResult = gamblers.getGamblers()
                 .stream()
-                .filter(result -> result == GameResult.LOSE)
-                .count();
+                .collect(Collectors.toMap(Gambler::getName, gambler -> {
+                    GameResult gameResult = GameResult.determine(dealerTotalScore, gambler.getTotalScore());
+                    if (gameResult == GameResult.WIN && gambler.isBlackJack()) {
+                        return gambler.getAmount() * 3 / 2;
+                    }
+                    if(gameResult == GameResult.WIN) return gambler.getAmount();
+                    if(gameResult == GameResult.LOSE) return -gambler.getAmount();
+                    return 0L;
+                }));
     }
 
-    public int countDealerLose() {
-        return (int) gamblersResult.values()
+    public Long getDealerResult() {
+        return -gamblersResult.values()
                 .stream()
-                .filter(result -> result == GameResult.WIN)
-                .count();
+                .mapToLong(Long::longValue)
+                .sum();
     }
 
-    public int countDealerDraw() {
-        return (int) gamblersResult
-                .values()
-                .stream()
-                .filter(result -> result == GameResult.DRAW)
-                .count();
+    public Long getMatchResult(String name) {
+        return gamblersResult.get(name);
     }
 
-    public Map<String, String> getResultInfo() {
-        return gamblersResult.entrySet()
-                .stream()
-                .collect(Collectors.toMap(Map.Entry::getKey,
-                        entry -> entry.getValue().getGameResult(),
-                        (a, b) -> a, LinkedHashMap::new
-                ));
+    public Map<String, Long> getResultInfo() {
+        return Collections.unmodifiableMap(gamblersResult);
     }
 }

src/main/java/domain/game/Game.java

@@ -19,10 +19,10 @@ public class Game {
     private final Gamblers gamblers;
     private final GameCards gameCards;
 
-    public Game(String dealerName, List<String> names, int amount) {
-        this.dealer = new Dealer(dealerName);
-        this.gamblers = new Gamblers(names);
-        this.gameCards = new GameCards(amount);
+    public Game(Dealer dealer, Gamblers gamblers, GameCards gameCards) {
+        this.dealer = dealer;
+        this.gamblers = gamblers;
+        this.gameCards = gameCards;
     }
 
     public void initializeGame() {
@@ -71,7 +71,7 @@ public List<Integer> getGamblersHandSize() {
     }
 
     public GamblersGameResult getResult(){
-        return new GamblersGameResult(dealer.getTotalScore(), gamblers.getParticipantTotalScore());
+        return new GamblersGameResult(dealer, gamblers);
     }
 }
 

src/main/java/domain/game/GameResult.java

@@ -1,6 +1,6 @@
 package domain.game;
 
-import static util.Constants.BLACK_JACK;
+import static util.Constants.BLACK_JACK_NUMBER;
 
 public enum GameResult {
 
@@ -15,8 +15,8 @@ public enum GameResult {
     }
 
     public static GameResult determine(int dealerScore, int gamblerScore) {
-        if(gamblerScore > BLACK_JACK) return LOSE;
-        if(dealerScore > BLACK_JACK) return WIN;
+        if(gamblerScore > BLACK_JACK_NUMBER) return LOSE;
+        if(dealerScore > BLACK_JACK_NUMBER) return WIN;
 
         if(dealerScore < gamblerScore) {
             return WIN;

src/main/java/domain/player/Dealer.java

@@ -2,10 +2,13 @@
 
 import static util.Constants.DEALER_REFERENCE_POINT;
 
+import domain.player.attribute.Hand;
+import domain.player.attribute.Name;
+
 public class Dealer extends Participant {
 
-    public Dealer(String name) {
-        super(name);
+    public Dealer(Name name, Hand hand) {
+        super(name, hand);
     }
 
     public boolean isTotalScore16OrLess() {

src/main/java/domain/player/Gambler.java

@@ -1,7 +1,19 @@
 package domain.player;
 
+import domain.player.attribute.Hand;
+import domain.player.attribute.Money;
+import domain.player.attribute.Name;
+
 public class Gambler extends Participant{
-    public Gambler(String name) {
-        super(name);
+
+    private final Money betAmount;
+
+    public Gambler(Name name, Hand hand, Money betAmount) {
+        super(name, hand);
+        this.betAmount = betAmount;
+    }
+
+    public Long getAmount() {
+        return betAmount.getBetAmount();
     }
 }