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

README.md

@@ -5,3 +5,81 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](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. 입력
+
+- 참여할 사람을 입력한다
+- 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,14 @@
+package blackjack;
+
+import blackjack.controller.BlackJackController;
+import blackjack.domain.card.ShuffledDeckFactory;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+
+public class Application {
+
+    public static void main(final String[] args) {
+        final BlackJackController blackJackController = new BlackJackController(new InputView(), new OutputView());
+        blackJackController.play(new ShuffledDeckFactory());
+    }
+}

src/main/java/blackjack/controller/BlackJackController.java

@@ -0,0 +1,127 @@
+package blackjack.controller;
+
+import static blackjack.controller.DomainConverter.convertCard;
+import static blackjack.controller.DomainConverter.convertCards;
+import static blackjack.controller.DomainConverter.convertPlayersCards;
+import static blackjack.controller.DomainConverter.getPlayerCards;
+import static blackjack.util.Repeater.repeatUntilNoException;
+
+import blackjack.domain.BlackJackRuleImpl;
+import blackjack.domain.card.DeckFactory;
+import blackjack.service.BlackJackGame;
+import blackjack.view.DrawCommand;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+import java.util.List;
+
+public class BlackJackController {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public BlackJackController(final InputView inputView, final OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    //이 메서드는 10라인도 훨씬 넘었고, 되게 복잡하게 되어있는데, 이렇게 두는 것이 좋은가요?
+    //원래대로 돌렸을 경우에, 훨씬 간단해보였던 것 같아요
+//    public void play(final DeckFactory deckFactory) {
+//        final BlackJackGame blackJackGame = repeatUntilNoException(
+//                () -> BlackJackGame.of(
+//                        inputPlayerNames(),
+//                        deckFactory,
+//                        new BlackJackRuleImpl()),
+//                outputView::printError);
+//
+//        for (final String playerName : blackJackGame.getPlayerNames()) {
+//            blackJackGame.addPlayerMoney(playerName, inputPlayerMoney(playerName));
+//        }
+//
+//        blackJackGame.distributeInitialCard();
+//
+//        outputView.printInitialCards(
+//                convertCard(blackJackGame.getDealerFirstCard()),
+//                getPlayerCards(blackJackGame.getPlayers()));
+//
+//        for (final String playerName : blackJackGame.getPlayerNames()) {
+//            DrawCommand playerChoice = DrawCommand.DRAW;
+//            while (blackJackGame.isPlayerDrawable(playerName) && playerChoice != DrawCommand.STAY) {
+//                playerChoice = inputPlayerChoice(playerName);
+//                if (playerChoice == DrawCommand.DRAW) {
+//                    blackJackGame.drawPlayerCard(playerName);
+//                }
+//                outputView.printCardStatusOfPlayer(playerName, convertCards(blackJackGame.getPlayerCards(playerName)));
+//            }
+//        }
+//
+//        while (blackJackGame.isDealerDrawable()) {
+//            blackJackGame.drawDealerCard();
+//            outputView.printDealerCardDrawMessage();
+//        }
+//
+//        outputView.printFinalStatusOfDealer(blackJackGame.getDealerScore(),
+//                convertCards(blackJackGame.getDealerCards()));
+//        outputView.printFinalStatusOfPlayers(convertPlayersCards(blackJackGame.getPlayersCards()),
+//                blackJackGame.getPlayersScores());
+//
+//        outputView.printFinalMoney(blackJackGame.calculatePlayersMoney());
+//    }
+
+    //한 메서드가 너무 길어지는 느낌이 드는 것 같은데요 이것은 어떤가요?
+    public void play(final DeckFactory deckFactory) {
+        final BlackJackGame blackJackGame = repeatUntilNoException(
+                () -> BlackJackGame.of(
+                        inputPlayerNames(),
+                        deckFactory,
+                        new BlackJackRuleImpl()),
+                outputView::printError);
+        for (final String playerName : blackJackGame.getPlayerNames()) {
+            blackJackGame.addPlayerMoney(playerName, inputPlayerMoney(playerName));
+        }
+
+        blackJackGame.distributeInitialCard();
+        outputView.printInitialCards(
+                convertCard(blackJackGame.getDealerFirstCard()),
+                getPlayerCards(blackJackGame.getPlayers()));
+
+        for (final String playerName : blackJackGame.getPlayerNames()) {
+            drawPlayerCard(blackJackGame, playerName);
+        }
+        while (blackJackGame.isDealerDrawable()) {
+            blackJackGame.drawDealerCard();
+            outputView.printDealerCardDrawMessage();
+        }
+
+        outputView.printFinalStatusOfDealer(blackJackGame.getDealerScore(),
+                convertCards(blackJackGame.getDealerCards()));
+        outputView.printFinalStatusOfPlayers(convertPlayersCards(blackJackGame.getPlayersCards()),
+                blackJackGame.getPlayersScores());
+        outputView.printFinalMoney(blackJackGame.calculatePlayersMoney());
+    }
+
+    private void drawPlayerCard(final BlackJackGame blackJackGame, final String playerName) {
+        DrawCommand playerChoice = DrawCommand.DRAW;
+        while (blackJackGame.isPlayerDrawable(playerName) && playerChoice != DrawCommand.STAY) {
+            playerChoice = inputPlayerChoice(playerName);
+            if (playerChoice == DrawCommand.DRAW) {
+                blackJackGame.drawPlayerCard(playerName);
+            }
+            outputView.printCardStatusOfPlayer(playerName, convertCards(blackJackGame.getPlayerCards(playerName)));
+        }
+    }
+
+    private int inputPlayerMoney(final String playerName) {
+        return repeatUntilNoException(
+                () -> inputView.inputPlayerMoney(playerName), outputView::printError);
+    }
+
+    private DrawCommand inputPlayerChoice(final String playerName) {
+        return repeatUntilNoException(
+                () -> inputView.inputCommand(playerName), outputView::printError);
+    }
+
+    private List<String> inputPlayerNames() {
+        return inputView.inputPlayerNames();
+    }
+}

src/main/java/blackjack/controller/DomainConverter.java

@@ -0,0 +1,54 @@
+package blackjack.controller;
+
+import blackjack.domain.card.Card;
+import blackjack.domain.participant.Players;
+import blackjack.response.CardResponse;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+//이 클래스는 controller 의 역할이지만, controller 에다가 두면, 너무 많은 역할을 하게 되는 것 같아서 분리하였습니다
+//이 클래스가 단순하게 유틸리티 비슷한 클래스인데, 이대로 괜찮을지 여쭤보고 싶어요
+class DomainConverter {
+
+    private DomainConverter() {
+    }
+
+    static CardResponse convertCard(final Card card) {
+        return CardResponse.from(card);
+    }
+
+    static List<CardResponse> convertCards(final List<Card> cards) {
+        return cards.stream()
+                .map(CardResponse::from)
+                .collect(Collectors.toList());
+    }
+
+    static Map<String, List<CardResponse>> getPlayerCards(final Players players) {
+        final List<String> playerNames = players.getPlayerNames();
+        final Map<String, List<CardResponse>> playerCards = new HashMap<>();
+        for (final String playerName : playerNames) {
+            final List<CardResponse> cardResponses = players.findPlayerByName(playerName)
+                    .getCards()
+                    .stream()
+                    .map(CardResponse::from)
+                    .collect(Collectors.toList());
+            playerCards.put(playerName, cardResponses);
+        }
+        return playerCards;
+    }
+
+    static Map<String, List<CardResponse>> convertPlayersCards(final Map<String, List<Card>> playersCards) {
+        return playersCards.entrySet().stream()
+                .collect(Collectors.toMap(
+                        Map.Entry::getKey,
+                        entry -> entry.getValue().stream()
+                                .map(CardResponse::from)
+                                .collect(Collectors.toList()),
+                        (oldValue, newValue) -> newValue,
+                        LinkedHashMap::new
+                ));
+    }
+}

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

@@ -0,0 +1,9 @@
+package blackjack.domain;
+
+import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Player;
+
+public interface BlackJackRule {
+
+    ResultType calculateDealerResult(Dealer dealer, Player player);
+}

src/main/java/blackjack/domain/BlackJackRuleImpl.java

@@ -0,0 +1,60 @@
+package blackjack.domain;
+
+import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Player;
+
+/**
+ * 이 클래스가 룰이 자주 변경될 수 있기에, 인터페이스를 둔다는 점은 좋은데요
+ * <p>
+ * 사실상 한 클래스만 존재하는 상황에서, 이를 interface로 빼는 것은 별로 의미가 없을 수 있어보이는데, 어떻게 생각하시나요?
+ */
+public class BlackJackRuleImpl implements BlackJackRule {
+
+    private static final int BUST_POINT = 21;
+
+    @Override
+    public ResultType calculateDealerResult(final Dealer dealer, final Player player) {
+        //이 부분이 애매해서 리팩토링을 해보려고 했는데, 더 좋은 방법이 생각나지 않아서 일단 이렇게 구현했습니다.
+        //enum 클래스에 BiPredicate를 추가해서 구현해보려고 했는데, enum 클래스에 메서드를 추가하는 것이 맞는지 잘 모르겠습니다.
+        if (isBlackJackWin(dealer, player)) {
+            return ResultType.BLACKJACK_WIN;
+        }
+        if (isBlackJackLose(dealer, player)) {
+            return ResultType.BLACKJACK_LOSE;
+        }
+        final int dealerScore = dealer.currentScore();
+        final int playerScore = player.currentScore();
+        if (isTie(dealerScore, playerScore)) {
+            return ResultType.TIE;
+        }
+        if (isDealerWin(dealerScore, playerScore)) {
+            return ResultType.WIN;
+        }
+        return ResultType.LOSE;
+    }
+
+    private boolean isBlackJackWin(final Dealer dealer, final Player player) {
+        return dealer.hasBlackJack() && !player.hasBlackJack();
+    }
+
+    private boolean isBlackJackLose(final Dealer dealer, final Player player) {
+        return !dealer.hasBlackJack() && player.hasBlackJack();
+    }
+
+    private boolean isTie(final int dealerScore, final int playerScore) {
+        if (playerScore > BUST_POINT && dealerScore > BUST_POINT) {
+            return true;
+        }
+        return playerScore == dealerScore;
+    }
+
+    private boolean isDealerWin(final int dealerScore, final int playerScore) {
+        if (playerScore > BUST_POINT) {
+            return true;
+        }
+        if (dealerScore > BUST_POINT) {
+            return false;
+        }
+        return dealerScore > playerScore;
+    }
+}

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

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