[2단계 - 블랙잭 베팅] 로빈(임수빈) 미션 제출합니다!

README.md

@@ -1,7 +1,108 @@
-# java-blackjack
+## 기능 요구 사항
 
-블랙잭 미션 저장소
+### 플레이어 이름 입력
 
-## 우아한테크코스 코드리뷰
+1. 플레이어의 이름은 ","을 기준으로 구분한다.
+2. 플레이어의 이름은 길이가 1 이상이어야 한다.
+3. 플레이어의 이름은 알파벳 대소문자와 숫자로만 구성되어야 한다.
+4. 플레이어의 이름은 중복되면 안된다.
 
-- [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+### 플레이어 및 딜러 점수 계산
+
+1. 플레이어가 소유한 카드의 점수의 합이 플레이어의 점수다.
+2. 카드의 점수는 카드의 숫자로 계산한다.
+3. Ace 카드는 1 혹은 11 중 카드의 소유자가 더 유리한 것으로 계산한다.
+4. King, Queen, Jack은 각각 10으로 계산한다.
+
+### 게임 진행 규칙
+
+1. 플레이어는 돈을 배팅한다.
+2. 모든 플레이어와 딜러는 카드를 2장씩 가지고 시작한다.
+3. 딜러는 두 장의 카드 중 첫번째 카드를 공개하지 않고, 플레이어는 모든 카드를 공개한다.
+4. 처음 가진 점수가 21점인 경우 BlackJack 이라 부른다. 플레이어와 딜러가 모두 BlackJack인 경우 무승부, 그렇지 않은 경우 BlackJack인 참가자가 승리한다.
+5. 플레이어는 서로 돌아가면서 자기 턴을 가진다.
+6. 플레이어는 자신의 턴에 자신이 카드를 더 받을지 말지 선택할 수 있다. 단, 자신의 점수가 21 이상인 경우 카드를 더 받을 수 없다.
+7. 플레이어는 한 번 카드를 받지 않기로 결정한 경우, 앞으로의 턴에서 카드를 더 받을 수 없다.
+8. 모든 플레이어가 카드를 더 받을 수 없는 경우, 딜러의 턴으로 넘어간다.
+9. 딜러의 턴에서 딜러는 딜러의 점수가 16점 이하인 경우 카드를 더 받는다. 17점 이상인 경우 카드를 더 받지 않는다.
+10. 딜러의 턴이 끝나면, 최종 점수 계산 및 게임의 승패를 가린다.
+11. 최종 점수가 21점에 가장 가까우면서 21점을 넘기지 않는 사람이 승리한다. 동점인 플레이어(딜러 포함)이 나온 경우, 무승부로 판단한다.
+12. 딜러가 21점을 넘긴 경우 딜러가 패배한다.
+13. 정해진 규칙대로 배팅금액을 정산한다.
+
+### 배팅 금액 정산 규칙
+
+1. 플레이어가 블랙잭으로 이긴 경우 딜러로부터 배팅 금액의 1.5배를 추가로 받는다.
+2. 플레이어가 이긴 경우 딜러로부터 배팅 금액만큼 추가로 받는다.
+3. 플레이어가 진 경우 플레이어는 배팅 금액을 모두 잃는다.
+
+### 게임 진행 상황 출력
+
+1. 게임이 시작 되자마자, 딜러와 플레이어가 받은 카드를 출력한다.
+2. 단, 딜러는 카드를 한장만 출력한다.
+3. 이 후 플레이어의 차례마다 플레이어가 소유한 카드를 출력한다.
+
+### 게임 결과 출력
+
+1. 게임을 완료한 후 각 플레이어(딜러 포함)가 보유한 카드 및 점수를 출력한다.
+2. 게임을 완료한 후 각 플레이어별로 승패를 출력한다.
+    - 딜러는 다른 모든 플레이어에 대한 승패가 출력된다.
+    - 딜러가 아닌 플레이어는 딜러에 대한 승패가 출력된다.
+
+### 게임 진행 가이드 출력
+
+- 게임의 원활한 진행을 위해 가이드 문구를 출력한다.
+
+## 기능 목록
+
+- [x] 플레이어 이름 입력 기능
+- [x] 카드 점수 계산 기능
+- [x] Ace 카드 점수 보정 기능
+- [x] 플레이어 및 딜러 점수 계산 기능
+- [x] 플레이어 및 딜러간 승부 계산 기능
+- [x] 플레이어 및 딜러 손패 출력 기능
+- [x] 게임 결과 출력 기능
+- [x] 게임 승부 결과 출력 기능
+- [x] 덱 관리 기능
+- [x] 보유한 카드 점수 합계 계산 기능
+- [x] 카드 받을지 여부 입력 기능
+- [x] 전체 게임 진행 기능
+- [x] 딜러 Ace 카드 점수 보정 기능
+
+## 1단계 피드백 반영 예정 목록
+
+- [x] 드로우가 가능한지 확인하는 책임 컨트롤러에서 다른 곳으로 이동
+- [x] 드로우 여부 결정하는 정책과 드로우 방식을 결정하는 정책 분리
+- [x] 의미 있는 상수화
+- [x] 테스트 코드에서 사용하는 테스트 객체 생성 역할을 분리
+- [x] view만을 위한 enum 추가
+- [x] Card Enum화
+
+## 2단계 구현 전 리팩토링
+
+- [x] GameResultCalculator가 Gamer를 매개변수로 받도록 리팩토링
+- [x] BlackJackGame 추가
+- [x] 대부분의 도메인 클래스 패키지 프라이빗으로 수정
+
+## 2단계 기능 목록
+
+- [x] 게임 결과 계산 기능(블랙잭인 경우 포함)
+- [x] 배팅 금액 등록 기능
+- [x] 승부에 따른 수익 계산 기능
+- [x] 최종 수익 계산 기능
+- [x] 최종 수익 출력 기능
+- [x] 배팅 금액 입력 기능
+
+## 2단계 피드백 반영 예정 목록
+
+- [x] BattingMoney 클래스 분리
+- [x] BlackJackController의 메서드 네이밍 수정
+- [x] DealerOutputView, PlayerOutputView 통합
+- [x] BlackJackGame 의 테스트 코드에서만 사용하는 생성자 삭제
+- [x] 메서드 선언 순서 변경
+- [x] enum 활용해 if문 제거
+- [x] 함수형 인터페이스 감싸서 클래스에 의미 부여
+- [x] stream map 내부 출력문 변경
+- [x] Card pool 코드 분리
+- [x] 딜러의 손패를 보여주는 행동을 전략패턴을 이용하도록 변경
+- [x] 플레이어와 딜러에서 카드를 선택하는 전략을 선택할 수 없도록 하기

src/main/java/Main.java

@@ -0,0 +1,8 @@
+import controller.BlackJackController;
+
+public class Main {
+    public static void main(String[] args) {
+        BlackJackController blackJackController = new BlackJackController();
+        blackJackController.start();
+    }
+}

src/main/java/controller/BlackJackController.java

@@ -0,0 +1,109 @@
+package controller;
+
+import domain.blackjack.BlackJackGame;
+import domain.blackjack.Dealer;
+import domain.blackjack.EarningMoney;
+import domain.blackjack.Player;
+import domain.blackjack.Players;
+import domain.blackjack.WithOutFirstCardShowStrategy;
+import domain.card.Card;
+import domain.card.Deck;
+import dto.GameResultDTO;
+import dto.GamerDTO;
+import java.util.List;
+import view.BattingMoneyInputView;
+import view.NameInputView;
+import view.OutputView;
+import view.YesOrNoInputView;
+import view.gamer.GamerOutputView;
+import view.gameresult.GameResultOutputView;
+
+public class BlackJackController {
+    public void start() {
+        Deck deck = Deck.fullDeck();
+        BlackJackGame blackJackGame = generateBlackJackGame();
+        initBlackJackGame(deck, blackJackGame);
+        printAllGamerBeforeRunGame(blackJackGame);
+        runGame(deck, blackJackGame);
+        printBlackJackGameResults(blackJackGame);
+    }
+
+    private BlackJackGame generateBlackJackGame() {
+        List<String> playerNames = NameInputView.getNames();
+        List<Integer> playersBattingMoney = BattingMoneyInputView.getMoney(playerNames);
+        return new BlackJackGame(playerNames, playersBattingMoney);
+    }
+
+    private static void initBlackJackGame(Deck deck, BlackJackGame blackJackGame) {
+        blackJackGame.initialDraw(deck);
+        Players players = blackJackGame.getPlayers();
+        List<String> playerNames = players.getPlayerNames();
+        OutputView.printInitGameDoneMessage(playerNames);
+    }
+
+    private void printAllGamerBeforeRunGame(BlackJackGame blackJackGame) {
+        Players players = blackJackGame.getPlayers();
+        printPlayers(players);
+        Dealer dealer = blackJackGame.getDealer();
+        printDealerWithoutFirstCard(dealer);
+    }
+
+    private void printPlayers(Players players) {
+        players.forEach(this::printPlayer);
+    }
+
+    private void printPlayer(Player player) {
+        GamerDTO playerDTO = GamerDTO.playerDTO(player.getRawName(), player.getRawHoldingCards(),
+                player.calculateSummationCardPointAsInt());
+        GamerOutputView.printWithoutSummationCardPoint(playerDTO);
+    }
+
+    private void printDealerWithoutFirstCard(Dealer dealer) {
+        List<Card> rawHoldingCards = dealer.getRawHoldingCards(WithOutFirstCardShowStrategy.INSTANCE);
+        GamerDTO dealerDTO = GamerDTO.dealerDTO(rawHoldingCards, dealer.calculateSummationCardPointAsInt());
+        GamerOutputView.printWithoutSummationCardPoint(dealerDTO);
+    }
+
+    private void runGame(Deck deck, BlackJackGame blackJackGame) {
+        playersTryDraw(deck, blackJackGame);
+        dealerTryDraw(deck, blackJackGame);
+    }
+
+    private void playersTryDraw(Deck deck, BlackJackGame blackJackGame) {
+        blackJackGame.playersDraw(deck, this::printPlayer, YesOrNoInputView::getYNAsBoolean);
+    }
+
+    private void dealerTryDraw(Deck deck, BlackJackGame blackJackGame) {
+        boolean isDealerDraw = blackJackGame.dealerTryDraw(deck);
+        if (isDealerDraw) {
+            OutputView.printDealerDrawDone();
+        }
+    }
+
+    private void printBlackJackGameResults(BlackJackGame blackJackGame) {
+        Players players = blackJackGame.getPlayers();
+        Dealer dealer = blackJackGame.getDealer();
+        printDealerWithPoint(dealer);
+        printPlayersWithPoint(players);
+
+        List<String> playerNames = players.getPlayerNames();
+        List<EarningMoney> playersEarningMoney = blackJackGame.calculatePlayersEarningMoney();
+        EarningMoney dealerEarningMoney = blackJackGame.calculateDealerEarningMoney();
+        GameResultDTO gameResultDTO = new GameResultDTO(playerNames, playersEarningMoney, dealerEarningMoney);
+        GameResultOutputView.print(gameResultDTO);
+    }
+
+    private void printDealerWithPoint(Dealer dealer) {
+        GamerDTO dealerDTO = GamerDTO.dealerDTO(dealer.getRawHoldingCards(),
+                dealer.calculateSummationCardPointAsInt());
+        GamerOutputView.print(dealerDTO);
+    }
+
+    private void printPlayersWithPoint(Players players) {
+        players.forEach(player -> {
+            GamerDTO playerDTO = GamerDTO.playerDTO(player.getRawName(), player.getRawHoldingCards(),
+                    player.calculateSummationCardPointAsInt());
+            GamerOutputView.print(playerDTO);
+        });
+    }
+}

src/main/java/domain/blackjack/AllCardShowStrategy.java

@@ -0,0 +1,16 @@
+package domain.blackjack;
+
+import domain.card.Card;
+import java.util.List;
+
+public class AllCardShowStrategy implements CardShowStrategy {
+    public static AllCardShowStrategy INSTANCE = new AllCardShowStrategy();
+
+    private AllCardShowStrategy() {
+    }
+
+    @Override
+    public List<Card> show(List<Card> allCards) {
+        return List.copyOf(allCards);
+    }
+}

src/main/java/domain/blackjack/BettingMoney.java

@@ -0,0 +1,14 @@
+package domain.blackjack;
+
+record BettingMoney(int rawBattingMoney) {
+    BettingMoney {
+        if (rawBattingMoney < 0) {
+            throw new IllegalArgumentException("배팅 금액은 음수일 수 없습니다.");
+        }
+    }
+
+    EarningMoney calculateEarningMoney(GameResult gameResult) {
+        double earnMoneyRate = gameResult.getEarnMoneyRate();
+        return new EarningMoney((int) (rawBattingMoney * earnMoneyRate));
+    }
+}

src/main/java/domain/blackjack/BlackJackGame.java

@@ -0,0 +1,52 @@
+package domain.blackjack;
+
+import domain.card.Deck;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class BlackJackGame {
+    private final Dealer dealer;
+    private final Players players;
+
+    public BlackJackGame(List<String> playerNames, List<Integer> battingMoneys) {
+        this.dealer = Dealer.of(HoldingCards.of());
+        this.players = new Players(playerNames, battingMoneys);
+    }
+
+    public void initialDraw(Deck deck) {
+        final int initialDrawCount = 2;
+        IntStream.range(0, initialDrawCount).forEach(index -> {
+            players.drawOnce(deck);
+            dealer.draw(deck);
+        });
+    }
+
+    public void playersDraw(Deck deck, PlayerDrawAfterCallBack playerDrawAfterCallBack,
+                            DrawConfirmation drawConfirmation) {
+        players.draw(deck, playerDrawAfterCallBack, drawConfirmation);
+    }
+
+    public boolean dealerTryDraw(Deck deck) {
+        DrawResult drawResult = dealer.draw(deck);
+        return drawResult.isSuccess();
+    }
+
+    public Dealer getDealer() {
+        return dealer;
+    }
+
+    public Players getPlayers() {
+        return players;
+    }
+
+    public List<EarningMoney> calculatePlayersEarningMoney() {
+        return players.calculatePlayersEarningMoney(dealer);
+    }
+
+    public EarningMoney calculateDealerEarningMoney() {
+        int dealerRawEarningMoney = -players.calculatePlayersEarningMoney(dealer).stream()
+                .mapToInt(EarningMoney::rawEarningMoney)
+                .sum();
+        return new EarningMoney(dealerRawEarningMoney);
+    }
+}

src/main/java/domain/blackjack/BlackJackGameMachine.java

@@ -0,0 +1,80 @@
+package domain.blackjack;
+
+import static domain.card.CardName.TEN;
+
+import domain.card.Card;
+import domain.card.CardDrawCondition;
+import domain.card.CardSelectStrategy;
+import domain.card.Deck;
+import java.util.List;
+
+class BlackJackGameMachine {
+    private static final int INITIAL_CARD_COUNT = 2;
+    private final HoldingCards holdingCards;
+
+    BlackJackGameMachine(HoldingCards holdingCards) {
+        this.holdingCards = holdingCards;
+    }
+
+    DrawResult draw(Deck deck, CardSelectStrategy cardSelectStrategy, CardDrawCondition cardDrawCondition) {
+        if (canDraw(deck, cardDrawCondition)) {
+            return DrawResult.fail();
+        }
+        try {
+            Card draw = deck.draw(cardSelectStrategy);
+            holdingCards.add(draw);
+            return DrawResult.success(!isBust());
+        } catch (IllegalArgumentException e) {
+            return DrawResult.fail(e, !isBust());
+        }
+    }
+
+    private boolean canDraw(Deck deck, CardDrawCondition cardDrawCondition) {
+        return isBust() || !cardDrawCondition.canDraw() || deck.isEmpty();
+    }
+
+    List<Card> getRawHoldingCards(CardShowStrategy cardShowStrategy) {
+        List<Card> allCards = holdingCards.getHoldingCards();
+        return List.copyOf(cardShowStrategy.show(allCards));
+    }
+
+    int calculateSummationCardPointAsInt() {
+        return calculateSummationCardPoint().summationCardPoint();
+    }
+
+    SummationCardPoint calculateSummationCardPoint() {
+        SummationCardPoint summationCardPoint = holdingCards.calculateTotalPoint();
+        if (hasAceInHoldingCards()) {
+            int rawPoint = fixPoint(summationCardPoint.summationCardPoint());
+            return new SummationCardPoint(rawPoint);
+        }
+        return summationCardPoint;
+    }
+
+    private boolean hasAceInHoldingCards() {
+        return holdingCards.hasAce();
+    }
+
+    private int fixPoint(int rawPoint) {
+        SummationCardPoint fixPoint = new SummationCardPoint(rawPoint + TEN.getCardNumber());
+        if (fixPoint.isDeadPoint()) {
+            return rawPoint;
+        }
+        return fixPoint.summationCardPoint();
+    }
+
+    boolean isBust() {
+        return calculateSummationCardPoint().isDeadPoint();
+    }
+
+    boolean isBlackJack() {
+        List<Card> rawHoldingCards = getRawHoldingCards();
+        int holdingCardCount = rawHoldingCards.size();
+        SummationCardPoint summationCardPoint = calculateSummationCardPoint();
+        return holdingCardCount == INITIAL_CARD_COUNT && summationCardPoint.isBlackJackPoint();
+    }
+
+    List<Card> getRawHoldingCards() {
+        return List.copyOf(holdingCards.getHoldingCards());
+    }
+}