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

README.md

@@ -13,87 +13,79 @@
     - **(예외 처리)** 공백 문자열인 경우
     - **(예외 처리)** `y` 혹은 `n`이 아닌 경우
 
+- 베팅 금액을 입력받는다
+    - 공백 문자열인 경우에 오류가 발생한다
+
 ### 출력
 
 - 게임 안내 문구를 출력한다.
     - 이름 입력 안내
     - HIT 혹은 STAND 여부 질문
     - 딜러의 카드 추가 여부
+    - 베팅 금액 입력 안내
 - 초기 카드 내역을 출력한다.
 - 최종 카드 내역을 출력한다.
 - 최종 승패 결과를 출력한다.
 
 ## 도메인
 
 ### MultiPlayers
-
 - 플레이어들 생성 및 관리
     - 이름 중복 검증
-- 플레이 가능한 사용자 찾기
-- 특정 플레이어에게 hit, stand 지시
-- 플레이어들의 게임 결과 조사
-- 플레이어들의 초기 카드 정보 조사
+    - **(예외 처리)** 플레이어 수가 5명을 초과할 경우 예외 발생 (`IllegalArgumentException`)
+    - **(예외 처리)** 중복된 이름이 존재할 경우 예외 발생 (`IllegalArgumentException`)
+- 플레이어 베팅 관리
+    - **(예외 처리)** 등록되지 않은 플레이어에게 액션을 지시할 경우 예외 발생
+- 게임 진행 대기 중인(Hit/Stand 가능한) 플레이어 탐색
+- 특정 플레이어에게 Hit/Stand 지시
+- 모든 플레이어의 초기 (카드) 상태 및 게임 승패 결과 조회
 
 ### Participant
-
 - 이름 검증
-    - 공백 불가
-    - 한국어, 알파벳만 허용
-- Hand를 이용한 보유 카드 정보 제공
-    - 초기 카드
-    - 구성
-    - 합
-- Hand를 이용한 Bust 정보 제공
-- Hand를 이용한 BlackJack 여부 제공
+    - **(예외 처리)** 이름이 공백인 경우 예외 발생
+    - **(예외 처리)** 영어나 한글 외의 문자가 포함된 경우 예외 발생
+- 참가자의 초기 부여 카드 및 전체 보유 카드 반환
+- 참가자가 베팅을 마쳤는지 여부 반환
+- 참가자가 보유한 카드 숫자의 총합 반환
 
 ### Dealer
-
-- 조건에 따른 카드 추가
-    - 점수 합이 16 이하인 경우
+- 점수 합이 16 이하인 경우 조건에 따른 카드 추가(Hit)
+- 점수가 16을 초과할 경우 자동으로 카드 추가 중지(Stay) 상태로 전환
+- 딜러의 초기 카드(1장) 반환 기능
 
 ### Player
-
-- 게임 진행 가능 여부 판별
-    - Hand를 이용하여 isBust 판별
-- 게임 진행 의사 관리
-- 초기 보유 카드 보여주기
-- Hand를 이용한 카드 추가
-- 조건에 따른 카드 추가
-    - 버스트 상태가 아닐 경우
+- 배팅 금액 관리 및 베팅 상태 점검
+- 플레이어 단위의 Hit/Stand 게임 진행 액션 수행
+- 게임 진행 가능 여부(Bust 또는 Blackjack 상태가 아님) 판별
+- 플레이어 턴의 종료 여부 확인 및 딜러와의 승패 결과(GameResult) 계산
+- 초기 부여받은 2장의 보유 카드 반환
 
 ### Card
+- 카드의 형상(Spade, Heart, Diamond, Club) 및 숫자(Ace ~ King) 정보 관리 및 제공
 
-- 카드 정보 관리 및 제공
+### BetAmount
+- 배팅 금액 추적 및 예외 상황 관리
+    - **(예외 처리)** 정수로 변환 불가능한 값 입력 시 예외 발생 (`IllegalArgumentException`)
+    - **(예외 처리)** 베팅 금액이 0원 이하일 경우 예외 발생 (`IllegalArgumentException`)
 
 ### Deck
-
-- 전체 카드 관리
-- 카드 1장 뽑기
-- 카드 2장 뽑기
+- 전략(Random 등) 기반 덱 구성 및 전체 카드 관리
+- 초기 부여용 카드 2장 뽑기 및 카드 1장 뽑기
+    - **(예외 처리)** 덱에 더 이상 카드가 남아있지 않은 상태에서 카드를 뽑으려 할 경우 예외 발생 (`IllegalArgumentException`)
 
 ### Hand
-
-- 사용자 보유 카드 관리
-- Bust 판정
-- blackJack 판정
-- 게임 조건에 따른 카드 추가
-- 총점 계산
+- 보유 카드의 상태(Bust, Blackjack, 보유 카드 총점) 판단
+- 게임 조건에 맞춰 카드를 추가해 새로운 핸드 구성 반환
 
 ### BlackJackGame
-
-- 게임 준비
-    - 딜러, 플레이어들, 전체 덱 생성
-- 게임의 turn 관리.
-- 특정 사용자를 찾아 hit / stand 실행
-- 모든 게임 참가자들의 초기 정보 조사
-- 모든 게임 참가자들의 결과 조사
+- 게임 준비 (딜러, 멀티 플레이어들, 전체 덱 생성)
+- 현재 누구의 턴(베팅 턴 또는 플레이 턴)인지 확인 및 상태 추적
+- 현재 턴인 사용자에 맞게 Hit, Stand, 혹은 Dealer Play 단계 실행
+    - **(예외 처리)** 베팅을 진행할 플레이어가 없는데 베팅을 시도할 경우 예외 발생 (`IllegalStateException`)
+    - **(예외 처리)** 카드를 더 이상 받을 수 있는 플레이어가 없는데 Hit/Stand를 시도할 경우 예외 발생 (`IllegalStateException`)
+- 모든 게임 참가자들의 초기 상태 및 최종 결과 정보 조사 반환
 
 ### BlackJackController
-
-- 게임 전반에서 필요한 I/O 관리
-    - 게임 진행 상황 출력 관리
-        - 초기 상태
-        - 특정 단계에서의 사용자 정보
-    - 사용자 이름 입력 관리
-    - hit 혹은 stand 여부 입력 관리
-    - 게임 결과 출력 관리
+- 입출력(View)과 도메인 모델 간의 데이터 연동 및 전체 게임 흐름 제어
+- 초기 설정(참가자 등록), 베팅 턴 진행, 플레이 턴 진행 단계별 실행
+- 예외 상황 발생 시 에러 메시지를 출력하고, 정상 입력이 들어올 때까지 반복 입력(I/O Retry) 흐름 관리

src/main/java/common/ErrorMessage.java

@@ -8,8 +8,11 @@ public enum ErrorMessage {
     ONLY_KO_AND_ENG("이름은 영어 또는 한국어만 가능합니다: "),
     NAME_UNIQUENESS_ERR("이름은 중복되면 안됩니다"),
     PLAYER_NOT_FOUND("해당 플레이어를 찾을 수 없습니다"),
-    NO_MORE_PLAYABLE_PLAYER("더 이상 게임을 진행할 수 있는 플레이어가 없습니다."),
+    NO_MORE_PLAYABLE_PLAYER("더 이상 게임을 진행할 수 있는 플레이어를 찾지 못했습니다"),
+    NO_MORE_BETTABLE_PLAYER("베팅을 진행할 수 있는 플레이어를 찾지 못했습니다"),
     NOT_ALLOW_METHOD_CALL("현재 상태에서 허용되지 않는 메소드 호출입니다"),
+    ZERO_MINUS_MONEY("0원 이하 금액을 베팅할 수는 없습니다"),
+    ONLY_NUMBER("숫자만 입력 가능합니다"),
     MAX_PLAYER_ERROR("최대 인원을 초과했습니다.");
 
     private final String message;

src/main/java/controller/BlackJackController.java

@@ -25,10 +25,8 @@ public BlackJackController(InputView inputView,
 
     public void doGameProcess() {
         BlackJackGame game = retry(this::readyGame);
-        outputView.printInitialStates(
-                game.getDealerGameSettingState(),
-                game.getPlayersGameSettingStates()
-        );
+        betPlayers(game);
+        outputView.printInitialStates(game.getGameSettingState());
 
         playPlayersTurn(game);
         playDealerTurn(game);
@@ -37,6 +35,15 @@ public void doGameProcess() {
         outputView.printGameResult(gameResults);
     }
 
+    private void betPlayers(BlackJackGame game) {
+        while (game.whoseBettingTurn().isPresent()) {
+            Player currentPlayer = game.whoseBettingTurn().get();
+            outputView.printBetAmountPrompt(currentPlayer.getName());
+            String betAmountValue = retry(inputView::readBetAmountValue);
+            game.doBetProcess(betAmountValue);
+        }
+    }
+
     private BlackJackGame readyGame() {
         outputView.printNamePrompt();
         List<String> playerNames = inputView.readNames();
@@ -50,22 +57,16 @@ private void playDealerTurn(BlackJackGame game) {
     }
 
     private void playPlayersTurn(BlackJackGame game) {
-        while (game.whoseTurn().isPresent()) {
-            Player currentPlayer = game.whoseTurn().get();
-
-            if (currentPlayer.isFinished()) {
-                handlePlayerStandProcess(game);
-                continue;
-            }
-
+        while (game.whosePlayTurn().isPresent()) {
+            Player currentPlayer = game.whosePlayTurn().get();
             outputView.printHitOrStandPrompt(currentPlayer.getName());
-            String hitOrStandInfo = retry(inputView::readHitOrStand);
-            doHitOrStand(hitOrStandInfo, game);
+            boolean wantToHit = retry(inputView::wantToHit);
+            doHitOrStand(wantToHit, game);
         }
     }
 
-    private void doHitOrStand(String hitOrStand, BlackJackGame game) {
-        if (hitOrStand.equals("y")) {
+    private void doHitOrStand(boolean wantToHit, BlackJackGame game) {
+        if (wantToHit) {
             handlePlayerHitProcess(game);
         } else {
             handlePlayerStandProcess(game);
@@ -93,5 +94,4 @@ private <T> T retry(Supplier<T> supplier) {
             }
         }
     }
-}
-
+}

src/main/java/domain/BetAmount.java

@@ -0,0 +1,36 @@
+package domain;
+
+import common.ErrorMessage;
+
+public record BetAmount(
+        int betAmount
+) {
+    public static BetAmount of(String betAmountValue) {
+        int betAmount = parseBetAmount(betAmountValue);
+        validatePositiveNumber(betAmount);
+        return new BetAmount(betAmount);
+    }
+
+    private static void validatePositiveNumber(int betAmount) {
+        if (betAmount <= 0) {
+            throw new IllegalArgumentException(ErrorMessage.ZERO_MINUS_MONEY.getMessage());
+        }
+    }
+
+    private static int parseBetAmount(String betAmountValue) {
+        try {
+            return Integer.parseInt(betAmountValue);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException(ErrorMessage.ONLY_NUMBER.getMessage());
+        }
+    }
+
+    public static BetAmount empty() {
+        return new BetAmount(0);
+    }
+
+    public boolean isBetPlaced() {
+        return betAmount != 0;
+    }
+}
+

src/main/java/domain/BlackJackGame.java

@@ -4,6 +4,7 @@
 import domain.state.GameState;
 import dto.DealerResultDto;
 import dto.GameResultDto;
+import dto.GameStateDto;
 import dto.ParticipantDto;
 import dto.PlayerResultDto;
 import java.util.List;
@@ -36,14 +37,24 @@ private static Dealer createNewDealer(Deck totalDeck) {
                 dealersInitialCards.get(1)
         );
         return Dealer.from(
-                GameState.createDealerInitialGameState(initialDealerHand)
+                GameState.createInitialGameState(initialDealerHand)
         );
     }
 
-    public Optional<Player> whoseTurn() {
+    public Optional<Player> whoseBettingTurn() {
+        return multiPlayers.findNotBetPlayer();
+    }
+
+    public Optional<Player> whosePlayTurn() {
         return multiPlayers.findNotStayPlayer();
     }
 
+    public void doBetProcess(String betAmountValue) {
+        Player target = multiPlayers.findNotBetPlayer()
+                .orElseThrow(() -> new IllegalStateException(ErrorMessage.NO_MORE_BETTABLE_PLAYER.getMessage()));
+        multiPlayers.executeBet(target, betAmountValue);
+    }
+
     public ParticipantDto doHitProcess() {
         Player newPlayer = multiPlayers.findNotStayPlayer()
                 .map(player -> multiPlayers.executeHit(player, totalDeck::drawCard))
@@ -64,12 +75,11 @@ public boolean doDealerHitOrStandProcess() {
         return !newDealer.gameState.isFinished();
     }
 
-    public List<ParticipantDto> getPlayersGameSettingStates() {
-        return multiPlayers.getInitialStates();
-    }
-
-    public ParticipantDto getDealerGameSettingState() {
-        return ParticipantDto.consistWithInitialInfo(dealer);
+    public GameStateDto getGameSettingState() {
+        return GameStateDto.from(
+                ParticipantDto.consistWithInitialInfo(dealer),
+                multiPlayers.getInitialStates()
+        );
     }
 
     public GameResultDto getGameResults() {

src/main/java/domain/Dealer.java

@@ -6,6 +6,7 @@
 
 public class Dealer extends Participant {
     private static final String DEALER_NAME = "딜러";
+    private static final int DEALER_CARD_SUM_MIN = 16;
 
     private Dealer(GameState gameState) {
         super(DEALER_NAME, gameState);
@@ -22,7 +23,11 @@ public List<Card> showInitialCard() {
     }
 
     public Dealer addCard(Supplier<Card> cardSupplier) {
-        GameState newGameState = gameState.hit(cardSupplier);
-        return Dealer.from(newGameState);
+        if (gameState.getCardsSum() <= DEALER_CARD_SUM_MIN) {
+            GameState newGameState = gameState.hit(cardSupplier);
+            return Dealer.from(newGameState);
+        }
+        GameState stayGameState = gameState.stay();
+        return Dealer.from(stayGameState);
     }
 }

src/main/java/domain/GameResult.java

@@ -3,9 +3,25 @@
 import domain.state.GameState;
 
 public enum GameResult {
-    승, 무, 패;
+    블랙잭(1.5),
+    승(1),
+    무(0),
+    패(-1);
+
+    private final double allocation;
+
+    GameResult(double allocation) {
+        this.allocation = allocation;
+    }
+
+    public double getAllocation() {
+        return allocation;
+    }
+
+    public static GameResult decidePlayerResult(Player player, Dealer dealer) {
+        GameState playerGameState = player.gameState;
+        GameState dealerGameState = dealer.gameState;
 
-    public static GameResult decidePlayerResult(GameState playerGameState, GameState dealerGameState) {
         if (playerGameState.isBust()) {
             return GameResult.패;
         }
@@ -16,7 +32,7 @@ public static GameResult decidePlayerResult(GameState playerGameState, GameState
             return GameResult.무;
         }
         if (playerGameState.isBlackJack()) {
-            return GameResult.승;
+            return GameResult.블랙잭;
         }
         if (dealerGameState.isBlackJack()) {
             return GameResult.패;
@@ -45,4 +61,4 @@ public GameResult reverse() {
 
         return GameResult.무;
     }
-}
+}