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,95 @@
+package blackjack;
+
+import blackjack.domain.card.Deck;
+import blackjack.domain.card.ShuffledDeckFactory;
+import blackjack.domain.participant.Participants;
+import blackjack.domain.participant.Player;
+import blackjack.domain.service.BlackJackRule;
+import blackjack.view.DrawCommand;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class Application {
+
+    public static void main(final String[] args) {
+        final InputView inputView = new InputView();
+        final OutputView outputView = new OutputView();
+        final List<String> playerNames = inputPlayerNames(inputView);
+        final List<Integer> moneys = new ArrayList<>();
+        for (final String playerName : playerNames) {
+            moneys.add(inputPlayerMoney(inputView, playerName));
+        }
+        final Deck deck = new ShuffledDeckFactory().generate();
+        final Participants participants = Participants.of(playerNames, moneys);
+        participants.distributeInitialCards(deck);
+        outputView.printInitialCards(participants.getDealerFirstCard(), participants.getPlayersCards());
+
+        for (final String playerName : participants.getPlayerNames()) {
+            DrawCommand playerChoice = DrawCommand.DRAW;
+            while (participants.isPlayerDrawable(playerName) && playerChoice != DrawCommand.STAY) {
+                playerChoice = inputPlayerChoice(playerName, inputView);
+                if (playerChoice == DrawCommand.DRAW) {
+                    participants.drawPlayerCard(playerName, deck.popCard());
+                }
+                outputView.printCardStatusOfPlayer(playerName, participants.getPlayerCards(playerName));
+            }
+        }
+        while (participants.isDealerDrawable()) {
+            participants.drawDealerCard(deck.popCard());
+            outputView.printDealerCardDrawMessage();
+        }
+
+        outputView.printFinalStatusOfDealer(participants.getDealerScore(),
+                participants.getDealerCards());
+        outputView.printFinalStatusOfPlayers(participants.getPlayersCards(),
+                participants.getPlayersScores());
+
+        final Map<String, Integer> playerMoney = new LinkedHashMap<>();
+        for (final Player player : participants.getPlayers()) {
+            final int resultMoney = new BlackJackRule().calculatePlayerProfit(player, participants.getDealer());
+            playerMoney.put(player.getName(), resultMoney);
+        }
+        outputView.printFinalMoney(playerMoney);
+    }
+
+    private static List<String> inputPlayerNames(final InputView inputView) {
+        return repeatUntilNoException(() -> {
+                    final List<String> names = inputView.inputPlayerNames();
+                    Participants.validatePlayerNames(names);
+                    return names;
+                },
+                inputView::printInputError);
+    }
+
+    private static int inputPlayerMoney(final InputView inputView,
+            final String playerName) {
+        return repeatUntilNoException(() -> {
+                    final int amount = inputView.inputPlayerMoney(playerName);
+                    Participants.validateBettingMoney(amount);
+                    return amount;
+                },
+                inputView::printInputError);
+    }
+
+    private static DrawCommand inputPlayerChoice(final String playerName, final InputView inputView) {
+        return repeatUntilNoException(
+                () -> inputView.inputCommand(playerName), inputView::printInputError);
+    }
+
+    private static <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/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;
+    }
+}

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

@@ -0,0 +1,28 @@
+package blackjack.domain.card;
+
+public class Card {
+
+    private final Shape shape;
+    private final Symbol symbol;
+
+    public Card(final Shape shape, final Symbol symbol) {
+        this.shape = shape;
+        this.symbol = symbol;
+    }
+
+    boolean isAce() {
+        return symbol.isAce();
+    }
+
+    int getScore() {
+        return symbol.getScore();
+    }
+
+    public Symbol getSymbol() {
+        return symbol;
+    }
+
+    public Shape getShape() {
+        return shape;
+    }
+}

src/main/java/blackjack/domain/card/CardPocket.java

@@ -0,0 +1,77 @@
+package blackjack.domain.card;
+
+import blackjack.domain.card.dto.CardResponse;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class CardPocket {
+
+    private static final int BUST_SCORE = 21;
+    private static final int BLACKJACK_SCORE = 21;
+    private static final int VALUE_ACE = 10;
+
+    private final List<Card> cards;
+
+    private CardPocket(final List<Card> cards) {
+        validateCardPocket(cards);
+        this.cards = new ArrayList<>(cards);
+    }
+
+    public static CardPocket empty() {
+        return new CardPocket(new ArrayList<>());
+    }
+
+    private void validateCardPocket(final List<Card> cards) {
+        if (cards == null) {
+            throw new IllegalArgumentException("카드에 null 값이 들어갈 수 없습니다");
+        }
+    }
+
+    public void addCard(final Card card) {
+        cards.add(card);
+        calculateCurrentScore();
+    }
+
+    private int calculateCurrentScore() {
+        final int countOfAce = countAce();
+        int scoreOfCards = calculateMinimumScore();
+        for (int i = 0; i < countOfAce; i++) {
+            scoreOfCards = calculateAceScore(scoreOfCards);
+        }
+        return scoreOfCards;
+    }
+
+    public int calculateScore() {
+        return calculateCurrentScore();
+    }
+
+    private int countAce() {
+        return (int) cards.stream()
+                .filter(Card::isAce)
+                .count();
+    }
+
+    private int calculateMinimumScore() {
+        return cards.stream()
+                .mapToInt(Card::getScore)
+                .sum();
+    }
+
+    private int calculateAceScore(final int score) {
+        if (score + VALUE_ACE > BUST_SCORE) {
+            return score;
+        }
+        return score + VALUE_ACE;
+    }
+
+    public List<CardResponse> getCards() {
+        return cards.stream()
+                .map(CardResponse::from)
+                .collect(Collectors.toList());
+    }
+
+    public boolean isBlackJack() {
+        return cards.size() == 2 && calculateScore() == BLACKJACK_SCORE;
+    }
+}

src/main/java/blackjack/domain/card/Deck.java

@@ -0,0 +1,32 @@
+package blackjack.domain.card;
+
+import java.util.Queue;
+
+public class Deck {
+
+    private static final int NUMBER_OF_CARDS_IN_DECK = 52;
+
+    private final Queue<Card> cards;
+
+    Deck(final Queue<Card> cards) {
+        validateCards(cards);
+        this.cards = cards;
+    }
+
+    private void validateCards(final Queue<Card> cards) {
+        if (cards == null) {
+            throw new IllegalArgumentException("카드에 null 이 들어왔습니다");
+        }
+        if (cards.size() != NUMBER_OF_CARDS_IN_DECK) {
+            throw new IllegalArgumentException(
+                    "카드 숫자는 " + NUMBER_OF_CARDS_IN_DECK + "장이어야 합니다 현재 :" + cards.size() + "장");
+        }
+    }
+
+    public Card popCard() {
+        if (cards.isEmpty()) {
+            throw new IllegalArgumentException("덱에 카드가 없습니다");
+        }
+        return cards.remove();
+    }
+}

src/main/java/blackjack/domain/card/DeckFactory.java

@@ -0,0 +1,6 @@
+package blackjack.domain.card;
+
+public interface DeckFactory {
+
+    Deck generate();
+}

src/main/java/blackjack/domain/card/Shape.java

@@ -0,0 +1,17 @@
+package blackjack.domain.card;
+
+public enum Shape {
+    HEART("하트"),
+    DIAMOND("다이아몬드"),
+    SPADE("스페이드"),
+    CLOVER("클로버");
+    private final String name;
+
+    Shape(final String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+}