[1단계 - 블랙잭 구현] 현구막(최현구) 미션 제출합니다.

README.md

@@ -2,4 +2,78 @@
 블랙잭 게임 미션 저장소
 
 ## 우아한테크코스 코드리뷰
-* [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+* [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+<br>
+
+## 기능 구현 목록
+- 참가자 추상 클래스 구현
+    - 플레이어 구현
+        - 손에 카드를 가지고 있다
+        - 카드를 받는다, 안받는다
+            - [x] y, n 이 아닌 다른 값 입력
+            - [x] 공백 또는 NULL
+        - 이름을 가지고 있는다
+            - [x] 공백 또는 NULL
+    - 딜러 구현
+        - 손에 카드를 가지고 있다
+        - 점수 총합이 16 이하일시 카드를 받는다
+        - 카드를 플레이어들에게 나눠준다
+- 카드덱 구현 Deque
+    - 카드 구현 Card 클래스
+        - 카드 숫자 Enum
+        - 카드 무늬 Enum
+    - 
+- 블랙잭 구현
+    - 플레이어들의 이름을 받는다
+        - [x] 플레이어의 이름 개수가 7개 초과
+    - 점수를 계산하여 승자를 판단한다
+    - 점수가 21을 초과할 경우 패배시킨다
+
+<br>
+
+## 테스트 구상 목록
+- 카드덱 뭉치
+    - [x] 사이즈가 52인지
+    - [x] 중복 카드가 입력 되었는지
+    - [x] 무늬별 13장씩 있는지
+    - [x] 무늬가 총 4개로 분류되는지
+    - [x] 덱에서 카드가 잘 나오는지
+- 카드
+    - [x] 카드가 잘 생성 되는지
+- 승패 테스트
+    - [x] 플레이어 승패 잘 판단되는지
+    - [x] 딜러 승패 잘 반환 되는지
+
+<br>
+
+## 질문 리스트
+- 카드 셔플을 딜러가 아닌 카드가 해도 되는지
+- 제네레이터 클래스를 만든것에 대해.
+- Number Enum 클래스가 번호별 출력양식을 가진 것에 대하여.
+    - 만일 OutputView 쪽에서 Enum별 출력 양식을 가지면 그건 도메인 역할을 침범하는게 아닌가?
+
+<br>
+
+## 리팩토링 구상 목록
+- `BlackjackManager`가 꼭 유틸 클래스일 필요가 있는가?
+    - `BlackjackManager` 가 꼭 유틸 클래스이지 말라는 법은 없지만, 꼭 유틸 클래스일 필요도 없다.
+    - 게다가, 대부분의 경우 유틸 클래스를 지양하라는 피드백을 받았었다.
+    - 대안 1. `BlackjackManager` 클래스를 제거한다.
+        - 미립이 `BlackjackManager` 존재의 필요성에 대해 의문을 표시해주셨다.
+        - "현재 컨트롤러가 `BlackjackManager`의 역할을 모두 수행하고 있는 것이 아닌가?"
+    - 대안 2. `BlackjackManager`가 덱을 갖도록 한다.
+        - 딜러가 카드를 꼭 나눠줄 필요가 없다. 객체지향은 현실세계 모방일뿐.
+        - 카드가 직접 딜러와 플레이어에게 나눠주는 행동을 하자.
+
+- Dto 변경
+    - `BlackjackManager` 를 서비스레이어처럼 생각하고 Dto를 만드는 역할 추가
+
+- 블랙잭 승패 비교를 GameResult Enum 클래스가 아닌 딜러가 하도록
+
+- `InputView` 이름 파싱 조금 더 여유롭게 (정규표현식 사용)
+
+- Controller 쪽으로 Player, Players, Dealer가 빠져나가지 않도록
+    - 핵심은 `BlackjackManager` 혹은 `Players` 쪽에 현재 플레이어를 기억할 방법을 찾는 것.
+
+- 도메인(`BlackjackManager`)이 Dto 로직을 모르도록

src/main/java/blackjack/Application.java

@@ -0,0 +1,11 @@
+package blackjack;
+
+import blackjack.controller.BlackjackController;
+
+public class Application {
+
+    public static void main(String[] args) {
+        BlackjackController blackjackController = new BlackjackController();
+        blackjackController.play();
+    }
+}

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

@@ -0,0 +1,84 @@
+package blackjack.controller;
+
+import blackjack.domain.BlackjackManager;
+import blackjack.domain.DtoAssembler;
+import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Players;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+import blackjack.view.dto.ParticipantDto;
+import blackjack.view.dto.ResultDto;
+import java.util.List;
+
+public class BlackjackController {
+
+    public void play() {
+        Dealer dealer = new Dealer();
+        Players players = new Players(InputView.getPlayerNames());
+        BlackjackManager blackjackManager = new BlackjackManager(dealer, players);
+
+        initDrawCardsDealerAndAllPlayers(blackjackManager);
+        hitOrStayAllPlayers(blackjackManager);
+        hitDealerUntilOverLimitScore(blackjackManager);
+        printCardsWithScoreOfDealerAndAllPlayers(blackjackManager);
+        printBlackjackResult(blackjackManager);
+    }
+
+    private void initDrawCardsDealerAndAllPlayers(BlackjackManager blackjackManager) {
+        blackjackManager.initDrawCards();
+        ParticipantDto dealerInitStatus = DtoAssembler
+            .createDealerInitStatusDto(blackjackManager.getDealer());
+        List<ParticipantDto> playerStatuses = DtoAssembler
+            .createPlayerStatusDtos(blackjackManager.getPlayers());
+        OutputView.printInitStatuses(dealerInitStatus, playerStatuses);
+    }
+
+    private void hitOrStayAllPlayers(BlackjackManager blackjackManager) {
+        while (!blackjackManager.isFinishedAllPlayers()) {
+            hitOrStayCurrentPlayer(blackjackManager);
+            blackjackManager.passTurnToNextPlayer();
+        }
+        blackjackManager.passTurnToNextPlayer();
+    }
+
+    private void hitOrStayCurrentPlayer(BlackjackManager blackjackManager) {
+        if (!blackjackManager.isFinishedCurrentPlayer()) {
+            blackjackManager.hitOrStayCurrentPlayer(
+                InputView.getHitOrStay(blackjackManager.getCurrentPlayerName()));
+            OutputView.printPlayerStatus(
+                DtoAssembler.createPlayerStatusDto(blackjackManager.getCurrentPlayer()));
+        }
+    }
+
+    private void hitDealerUntilOverLimitScore(BlackjackManager blackjackManager) {
+        OutputView.printNewLine();
+        while (!blackjackManager.isFinishedDealer()) {
+            hitOrStayDealer(blackjackManager);
+        }
+        OutputView.printNewLine();
+    }
+
+    private void hitOrStayDealer(BlackjackManager blackjackManager) {
+        if (blackjackManager.isDealerScoreOverThenLimit()) {
+            blackjackManager.stayDealer();
+            return;
+        }
+        blackjackManager.hitDealer();
+        OutputView.printDealerHit();
+    }
+
+    private void printCardsWithScoreOfDealerAndAllPlayers(BlackjackManager blackjackManager) {
+        OutputView
+            .printStatusWithScore(DtoAssembler.createDealerStatusDto(blackjackManager.getDealer()));
+        DtoAssembler.createPlayerStatusDtos(blackjackManager.getPlayers())
+            .forEach(OutputView::printStatusWithScore);
+    }
+
+    private void printBlackjackResult(BlackjackManager blackjackManager) {
+        Dealer dealer = blackjackManager.getDealer();
+        Players players = blackjackManager.getPlayers();
+        ResultDto dealerResult = DtoAssembler.createDealerResultDto(dealer, players);
+        List<ResultDto> playerResultDtos = DtoAssembler.createPlayerResultDtos(dealer, players);
+        OutputView.printBlackjackResult(dealerResult, playerResultDtos);
+    }
+}

src/main/java/blackjack/domain/BlackjackManager.java

@@ -0,0 +1,80 @@
+package blackjack.domain;
+
+import blackjack.domain.carddeck.CardDeck;
+import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Player;
+import blackjack.domain.participant.Players;
+
+public class BlackjackManager {
+
+    private final CardDeck cardDeck;
+    private final Dealer dealer;
+    private final Players players;
+
+    public BlackjackManager(final Dealer dealer, final Players players) {
+        this(CardDeck.newShuffledDeck(), dealer, players);
+    }
+
+    public BlackjackManager(final CardDeck cardDeck, final Dealer dealer, final Players players) {
+        this.cardDeck = cardDeck;
+        this.dealer = dealer;
+        this.players = players;
+    }
+
+    public void initDrawCards() {
+        this.dealer.initDraw(this.cardDeck);
+        this.players.initDraw(this.cardDeck);
+    }
+
+    public void hitOrStayCurrentPlayer(boolean isPlayerHit) {
+        if (isPlayerHit) {
+            this.players.drawFirstOrderPlayer(this.cardDeck.draw());
+            return;
+        }
+        this.players.stayFirstOrderPlayer();
+    }
+
+    public void passTurnToNextPlayer() {
+        this.players.passTurnToNextPlayer();
+    }
+
+    public boolean isFinishedCurrentPlayer() {
+        return this.players.isFinishedCurrentPlayer();
+    }
+
+    public boolean isFinishedAllPlayers() {
+        return this.players.isAllPlayerFinished();
+    }
+
+    public void hitDealer() {
+        this.dealer.draw(this.cardDeck.draw());
+    }
+
+    public void stayDealer() {
+        this.dealer.stay();
+    }
+
+    public boolean isDealerScoreOverThenLimit() {
+        return this.dealer.isOverThenLimitScore();
+    }
+
+    public boolean isFinishedDealer() {
+        return this.dealer.isFinished();
+    }
+
+    public Players getPlayers() {
+        return this.players;
+    }
+
+    public Player getCurrentPlayer() {
+        return this.players.getFirstOrderPlayer();
+    }
+
+    public String getCurrentPlayerName() {
+        return this.players.getFirstOrderPlayerName();
+    }
+
+    public Dealer getDealer() {
+        return this.dealer;
+    }
+}

src/main/java/blackjack/domain/DtoAssembler.java

@@ -0,0 +1,85 @@
+package blackjack.domain;
+
+import blackjack.domain.carddeck.Card;
+import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Player;
+import blackjack.domain.participant.Players;
+import blackjack.view.dto.CardDto;
+import blackjack.view.dto.ParticipantDto;
+import blackjack.view.dto.ResultDto;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class DtoAssembler {
+
+    private static final String DELIMITER = ", ";
+
+    public static ParticipantDto createDealerInitStatusDto(final Dealer dealer) {
+        return new ParticipantDto(
+            createCardDtos(dealer.getInitCard()),
+            dealer.getScoreToInt()
+        );
+    }
+
+    public static ParticipantDto createDealerStatusDto(Dealer dealer) {
+        return new ParticipantDto(
+            createCardDtos(dealer.getCards()),
+            dealer.getScoreToInt()
+        );
+    }
+
+    public static List<ParticipantDto> createPlayerStatusDtos(final Players players) {
+        return players.toList()
+            .stream()
+            .map(DtoAssembler::createPlayerStatusDto)
+            .collect(Collectors.toList())
+            ;
+    }
+
+    public static ParticipantDto createPlayerStatusDto(final Player player) {
+        return new ParticipantDto(
+            player.getName(),
+            createCardDtos(player.getCards()),
+            player.getScoreToInt()
+        );
+    }
+
+    private static List<CardDto> createCardDtos(final List<Card> cards) {
+        return cards.stream()
+            .map(card -> new CardDto(card.getNumberName() + card.getPatternName()))
+            .collect(Collectors.toList())
+            ;
+    }
+
+    public static ResultDto createDealerResultDto(final Dealer dealer, Players players) {
+        List<Result> results = getResults(dealer, players);
+        return new ResultDto(
+            getResultString(results, Result.WIN) + DELIMITER
+                + getResultString(results, Result.LOSE) + DELIMITER
+                + getResultString(results, Result.DRAW)
+        );
+    }
+
+    private static List<Result> getResults(final Dealer dealer, final Players players) {
+        return players.toList()
+            .stream()
+            .map(player -> player.judgeByDealerState(dealer))
+            .map(Result::reverse)
+            .collect(Collectors.toList());
+    }
+
+    private static String getResultString(final List<Result> results, final Result result) {
+        return results.stream()
+            .filter(compareResult -> compareResult.equals(result))
+            .count() + result.getResult();
+    }
+
+    public static List<ResultDto> createPlayerResultDtos(final Dealer dealer,
+        final Players players) {
+        return players.toList()
+            .stream()
+            .map(player -> new ResultDto(player.getName(),
+                player.judgeByDealerState(dealer).getResult()))
+            .collect(Collectors.toList());
+    }
+}

src/main/java/blackjack/domain/Result.java

@@ -0,0 +1,28 @@
+package blackjack.domain;
+
+public enum Result {
+
+    WIN("승"),
+    LOSE("패"),
+    DRAW("무");
+
+    private final String result;
+
+    Result(final String result) {
+        this.result = result;
+    }
+
+    public Result reverse() {
+        if (this == WIN) {
+            return LOSE;
+        }
+        if (this == LOSE) {
+            return WIN;
+        }
+        return DRAW;
+    }
+
+    public String getResult() {
+        return this.result;
+    }
+}