Step2 놀러와요 누누의 step2 블랙잭에

README.md

@@ -5,3 +5,105 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+```mermaid
+---
+title: 의존성그래프
+---
+graph TD
+BlackJackGame --> Players
+BlackJackGame --> Deck
+BlackJackGame --> Dealer
+
+Players --> Dealer
+Dealer --> Player
+
+Participant --> CardPocket
+Dealer --> Participant
+Player --> Participant
+
+Players --> Player
+Player --> Name
+CardPocket --> Card
+
+Deck --> Card
+Card --> Shape
+Card --> Symbol
+```
+
+# 기능구현 목록
+
+## UI
+
+1. 입력
+    - [x] 베팅 금액을 입력받는다
+2. 출력
+    - [x] 최종 수익을 출력한다
+
+## 도메인
+
+1. BettingMoney
+    - [x] 사용자에 베팅 금액을 받는다
+        - [예외처리] 0 이상의 숫자인지 확인한다
+    - [x] 베팅 금액에 대한 수익률을 계산한다
+2. CardPocket
+    - Card 와 관련된 도메인에 대한 애그리거트 루트입니다
+    - 도메인 외부로 조회된 결과를 반환할 때 CardResponse 형태로 바꾸어 반환합니다
+3. Participants
+    - 플레이어와 딜러에 대한 애그리거트 루트입니다
+    - 외부에서 발생하는 모든 조회는 Participant 를 통해 조회해야합니다
+4. ResultType
+    - 블랙잭 게임과 관련된 결과를 담당하는 클래스 입니다
+5. BLackjackRule
+    - 블랙잭 게임의 결과를 계산하는 도메인 서비스입니다
+    - Player 와, Dealer 를 받아서 수익률을 계산합니다
+
+## UI
+
+1. 입력
+
+- 참여할 사람을 입력한다
+- List<String>으로 변환 및 반환한다
+
+## 도메인
+
+1. Deck
+    - [x] 카드를 생성한다
+        - [x] 총 52장
+        - [x] Shape마다 13장을 출력
+    - [x] 카드를 나눠준다
+
+2. BlackJack
+    - 딜러와 플레이어에게 카드를 2장씩 나눠준다.
+      -- 카드를 나눠준다
+3. Participant
+    - [x] 21 이상인지 확인하고
+        - [x] 21 이상이라면,
+            - [x] 블랙잭인지 확인한다 = 받을 수 없음
+            - [x] BURST인지 확인한다 = 받을 수 없음4
+    - [x] 현재 점수를 숫자 형태로 반환한다
+    - [x] 현재 카드를 반환한다
+4. Player
+    - [x] 21 미만이면, 받을 수 있다는 boolean
+5. Dealer
+    - [x] 16 이하이면, 받을 수 있따는 boolean
+6. CardPocket
+    - [x]  카드의 Symbol 점수를 계산한다.(ScoreCalculator 역할)
+    - 카드반환 한다
+    - [x] 카드 계산 총합 반환
+7. Shape
+    - [x] enum 형태로 하트, 스페이스, 클로버, 다이아를 저장한다
+8. Symbol
+    - [x] a=1 2-9, j,q,k =10
+    - [x] value는 int 형으로 저장한다
+9. Card
+    - [x] Shape와 Symbol을 저장하는 자료구조
+
+10. Players
+    - [x] 플레이어 이름 중복
+    - [x] 플레이어 수 1명이상, 5명 이하
+    - [x] 플레이어에게 카드 나눠주기
+    - [x] 플레이어의 draw여부 알기
+11. Name
+    - [x] isBlank 체크
+    - [x] 100자 이하 체크

src/main/java/blackjack/Application.java

@@ -0,0 +1,17 @@
+package blackjack;
+
+import blackjack.controller.BlackjackController;
+import blackjack.view.IOView;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+
+public class Application {
+
+    public static void main(final String[] args) {
+        final IOView ioView = new IOView(new InputView(), new OutputView());
+        final BlackjackController blackjackController = new BlackjackController(ioView);
+        blackjackController.init();
+        blackjackController.play();
+        blackjackController.calculateResult();
+    }
+}

src/main/java/blackjack/controller/BlackjackController.java

@@ -0,0 +1,96 @@
+package blackjack.controller;
+
+import blackjack.domain.blackjack.BlackjackGame;
+import blackjack.domain.card.ShuffledDeckFactory;
+import blackjack.domain.participant.Participants;
+import blackjack.view.DrawCommand;
+import blackjack.view.IOView;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class BlackjackController {
+
+    private final IOView ioView;
+    private BlackjackGame blackjackGame;
+
+    public BlackjackController(final IOView ioView) {
+        this.ioView = ioView;
+    }
+
+    public void init() {
+        final List<String> playerNames = inputPlayerNames();
+        final List<Integer> moneys = new ArrayList<>();
+        for (final String playerName : playerNames) {
+            moneys.add(inputPlayerMoney(playerName));
+        }
+        blackjackGame = BlackjackGame.of(playerNames, moneys, new ShuffledDeckFactory().generate());
+        blackjackGame.distributeInitialCards();
+        ioView.printInitialCards(blackjackGame.getDealerFirstCard(), blackjackGame.getPlayersCards());
+    }
+
+    public void play() {
+        for (final String playerName : blackjackGame.getPlayerNames()) {
+            drawPlayerCards(playerName);
+        }
+        while (blackjackGame.isDealerDrawable()) {
+            blackjackGame.drawDealerCard();
+            ioView.printDealerCardDrawMessage();
+        }
+    }
+
+    public void calculateResult() {
+        ioView.printFinalStatusOfDealer(blackjackGame.getDealerScore(), blackjackGame.getDealerCards());
+        ioView.printFinalStatusOfPlayers(blackjackGame.getPlayersCards(), blackjackGame.getPlayersScores());
+        ioView.printFinalMoney(blackjackGame.calculateMoney());
+    }
+
+    private void drawPlayerCards(final String playerName) {
+        DrawCommand playerChoice = DrawCommand.DRAW;
+        while (blackjackGame.isPlayerDrawable(playerName) && playerChoice != DrawCommand.STAY) {
+            playerChoice = inputPlayerChoice(playerName);
+            drawPlayerCard(playerName, playerChoice);
+            ioView.printCardStatusOfPlayer(playerName, blackjackGame.getPlayerCards(playerName));
+        }
+    }
+
+    private void drawPlayerCard(final String playerName, final DrawCommand playerChoice) {
+        if (playerChoice == DrawCommand.DRAW) {
+            blackjackGame.drawPlayerCard(playerName);
+        }
+    }
+
+    private List<String> inputPlayerNames() {
+        return repeatUntilNoException(() -> {
+                    final List<String> names = ioView.inputPlayerNames();
+                    Participants.validatePlayerNames(names);
+                    return names;
+                },
+                ioView::printError);
+    }
+
+    private int inputPlayerMoney(final String playerName) {
+        return repeatUntilNoException(() -> {
+                    final int amount = ioView.inputPlayerMoney(playerName);
+                    Participants.validateBettingMoney(amount);
+                    return amount;
+                },
+                ioView::printError);
+    }
+
+    private DrawCommand inputPlayerChoice(final String playerName) {
+        return repeatUntilNoException(() -> ioView.inputCommand(playerName), ioView::printError);
+    }
+
+    private <T> T repeatUntilNoException(final Supplier<T> supplier,
+            final Consumer<Exception> exceptionHandler) {
+        while (true) {
+            try {
+                return supplier.get();
+            } catch (final IllegalArgumentException e) {
+                exceptionHandler.accept(e);
+            }
+        }
+    }
+}

src/main/java/blackjack/domain/blackjack/BlackJackRule.java

@@ -0,0 +1,51 @@
+package blackjack.domain.blackjack;
+
+import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Player;
+
+class BlackJackRule {
+
+    private static final int BUST_POINT = 21;
+
+    int calculatePlayerProfit(final Player player, final Dealer dealer) {
+        final ResultType result = calculatePlayerResult(dealer, player);
+        return player.calculateProfit(result.getPlayerProfit());
+    }
+
+    private ResultType calculatePlayerResult(final Dealer dealer, final Player player) {
+        if (dealer.hasBlackJack()) {
+            return playWithBlackjack(player);
+        }
+        if (dealer.currentScore() > BUST_POINT) {
+            return playWithBust(player);
+        }
+        return playWithScore(dealer, player);
+    }
+
+    private ResultType playWithBlackjack(final Player player) {
+        if (player.hasBlackJack()) {
+            return ResultType.TIE;
+        }
+        return ResultType.BLACKJACK_LOSE;
+    }
+
+    private ResultType playWithBust(final Player player) {
+        if (player.currentScore() > BUST_POINT) {
+            return ResultType.TIE;
+        }
+        if (player.hasBlackJack()) {
+            return ResultType.BLACKJACK_WIN;
+        }
+        return ResultType.WIN;
+    }
+
+    private ResultType playWithScore(final Dealer dealer, final Player player) {
+        if (player.hasBlackJack()) {
+            return ResultType.BLACKJACK_WIN;
+        }
+        if (player.currentScore() > BUST_POINT || dealer.currentScore() > player.currentScore()) {
+            return ResultType.LOSE;
+        }
+        return ResultType.WIN;
+    }
+}

src/main/java/blackjack/domain/blackjack/BlackjackGame.java

@@ -0,0 +1,82 @@
+package blackjack.domain.blackjack;
+
+import blackjack.domain.card.Deck;
+import blackjack.domain.card.dto.CardResponse;
+import blackjack.domain.participant.Participants;
+import blackjack.domain.participant.Player;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public class BlackjackGame {
+
+    private final Participants participants;
+    private final Deck deck;
+
+    private BlackjackGame(final Participants participants, final Deck deck) {
+        this.participants = participants;
+        this.deck = deck;
+    }
+
+    public static BlackjackGame of(final List<String> playerNames, final List<Integer> bettingMoneys, final Deck deck) {
+        return new BlackjackGame(Participants.of(playerNames, bettingMoneys), deck);
+    }
+
+    public void distributeInitialCards() {
+        participants.distributeInitialCards(deck);
+    }
+
+    public CardResponse getDealerFirstCard() {
+        return participants.getDealerFirstCard();
+    }
+
+    public Map<String, List<CardResponse>> getPlayersCards() {
+        return participants.getPlayersCards();
+    }
+
+    public List<String> getPlayerNames() {
+        return participants.getPlayerNames();
+    }
+
+    public boolean isDealerDrawable() {
+        return participants.isDealerDrawable();
+    }
+
+    public void drawDealerCard() {
+        participants.drawDealerCard(deck.popCard());
+    }
+
+    public boolean isPlayerDrawable(final String playerName) {
+        return participants.isPlayerDrawable(playerName);
+    }
+
+    public List<CardResponse> getPlayerCards(final String playerName) {
+        return participants.getPlayerCards(playerName);
+    }
+
+    public void drawPlayerCard(final String playerName) {
+        participants.drawPlayerCard(playerName, deck.popCard());
+    }
+
+    public int getDealerScore() {
+        return participants.getDealerScore();
+    }
+
+    public List<CardResponse> getDealerCards() {
+        return participants.getDealerCards();
+    }
+
+    public Map<String, Integer> getPlayersScores() {
+        return participants.getPlayersScores();
+    }
+
+    public Map<String, Integer> calculateMoney() {
+        final Map<String, Integer> playerMoney = new LinkedHashMap<>();
+        final BlackJackRule blackJackRule = new BlackJackRule();
+        for (final Player player : participants.getPlayers()) {
+            final int resultMoney = blackJackRule.calculatePlayerProfit(player, participants.getDealer());
+            playerMoney.put(player.getName(), resultMoney);
+        }
+        return playerMoney;
+    }
+}

src/main/java/blackjack/domain/blackjack/ResultType.java

@@ -0,0 +1,19 @@
+package blackjack.domain.blackjack;
+
+public enum ResultType {
+    BLACKJACK_WIN(1.5),
+    WIN(1),
+    TIE(0),
+    LOSE(-1),
+    BLACKJACK_LOSE(-1);
+
+    private final double playerProfit;
+
+    ResultType(final double playerProfit) {
+        this.playerProfit = playerProfit;
+    }
+
+    public double getPlayerProfit() {
+        return playerProfit;
+    }
+}