[Lev1][미션3] 블랙잭 1단계 - 다즐

README.md

@@ -5,3 +5,98 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+## 블랙잭 개요
+
+- 블랙잭 게임은 딜러와 플레이어가 진행한다.
+- 카드의 합이 21에 가장 가까운 숫자를 가지는 쪽이 이기는 게임이다.
+- 숫자 계산은 카드의 숫자를 기본으로 하되,
+    - Ace: 1 or 11
+    - King, Queen, Jack: 10
+- 게임을 시작하면, 딜러와 플레이어는 두 장의 카드를 지급받는다.
+- 플레이어는 카드 숫자의 합이 21 미만이라면 카드를 계속 뽑을 수 있다.
+- 딜러는 카드 숫자의 합이 16 이하인 경우에만 1장의 카드를 추가로 받아야 한다.
+    - 딜러는 최대 3장의 카드만 받을 수 있다.
+- 게임이 완료되면, 각 플레이어의 승패를 출력한다.
+
+## 블랙잭 규칙
+
+- `승`, `무`, `패`는 플레이어에 결과를 나타낸다.
+- 플레이어 점수가 21점 초과일 때
+    - 딜러 점수 상관없이 `패`
+- 플레이어 점수가 21점 이하일 때
+    - 딜러 점수가 21점 초과일 떄
+        - 플레이어 `승`
+    - 딜러 점수가 21점 이하일 때
+        - 플레이어 점수가 높으면 `승`
+        - 플레이어 점수가 낮으면 `패`
+        - 플레어어 점수와 같으면 `무`
+
+## 도메인 다이어그램
+
+```mermaid
+graph TD
+    BlackJackController --> InputView
+    BlackJackController --> OutputView
+    BlackJackController --> Participants
+    BlackJackController --> Deck
+    InputView --> Parser
+    Participants --> Participant
+    Participant --> Player
+    Participant --> Dealer
+    Participant --> Cards
+    Player --> PlayerName
+    Dealer --> Result
+    Cards --> Card
+    Card --> Suit
+    Card --> Number
+```
+
+## 기능 구현 목록
+
+### 참가자
+
+- [x] 카드를 받는다.
+- [x] 점수를 확인한다.
+- [x] 카드 추가 여부를 결정한다.
+- [x] 여러 명일 수 있다.
+    - [x] 딜러는 포함되어야 한다.
+    - [x] 중복되는 이름은 가질 수 없다.
+    - [x] 최대 6명이다.
+
+### 플레이어
+
+- [x] 이름을 가진다.
+    - [x] 최소 1자, 최대 10자까지 가능하다.
+    - [x] 중간 공백은 허용한다.
+    - [x] `딜러`라는 이름은 가질 수 없다.
+
+### 카드
+
+- [x] 문양을 가진다.
+- [x] 숫자를 가진다.
+- [x] 점수를 계산한다.
+- [x] 에이스인지 확인한다.
+- [x] 점수 최댓값 초과 여부를 확인한다.
+- [x] 점수 최댓값 여부를 확인한다.
+- [x] 카드를 추가한다.
+- [x] 카드 개수를 확인한다.
+
+### 덱
+
+- [x] 카드 목록을 가진다.
+- [x] 카드를 뽑는다.
+    - [x] 카드가 없으면 뽑을 수 없다.
+
+### 입력
+
+- [x] 플레이어의 이름을 입력한다.
+    - [x] 앞, 뒤 공백은 제거한다.
+- [x] 카드를 받을 여부를 입력한다.
+
+### 출력
+
+- [x] 딜러와 플레이어의 카드 현황을 출력한다.
+- [x] 딜러 카드 추가 여부를 출력한다.
+- [x] 최종 결과를 출력한다.
+- [x] 최종 승패를 출력한다.

src/main/java/blackjack/BlackJackApplication.java

@@ -0,0 +1,16 @@
+package blackjack;
+
+import blackjack.controller.BlackJackController;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+
+public class BlackJackApplication {
+
+    public static void main(String[] args) {
+        final InputView inputView = new InputView();
+        final OutputView outputView = new OutputView();
+
+        final BlackJackController blackJackController = new BlackJackController(inputView, outputView);
+        blackJackController.run();
+    }
+}

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

@@ -0,0 +1,142 @@
+package blackjack.controller;
+
+import blackjack.domain.card.Card;
+import blackjack.domain.card.Deck;
+import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Participant;
+import blackjack.domain.participant.Participants;
+import blackjack.domain.participant.Player;
+import blackjack.domain.participant.Result;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+import blackjack.view.dto.CardsResponse;
+import blackjack.view.dto.DealerResultResponse;
+import blackjack.view.dto.DealerStateResponse;
+import blackjack.view.dto.ParticipantResponse;
+import blackjack.view.dto.PlayerResultResponse;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class BlackJackController {
+
+    private static final int INITIAL_DRAW_COUNT = 2;
+
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public BlackJackController(final InputView inputView, final OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void run() {
+        final Participants participants = new Participants(new Dealer(), gatherPlayers());
+        final Deck deck = Deck.createUsingTrump(1);
+
+        dealCards(participants, deck);
+
+        drawCard(participants.getPlayers(), deck);
+        drawCard(participants.getDealer(), deck);
+
+        printResult(participants);
+    }
+
+    private List<Player> gatherPlayers() {
+        final List<String> playerNames = inputView.readPlayerNames();
+        return playerNames.stream()
+                .map(Player::new)
+                .collect(Collectors.toList());
+    }
+
+    private void dealCards(final Participants participants, final Deck deck) {
+        participants.drawCard(deck, INITIAL_DRAW_COUNT);
+
+        final ParticipantResponse dealerResponse = getHiddenDealerResponse(participants.getDealer());
+        final List<ParticipantResponse> playerResponse = getParticipantResponses(participants.getPlayers());
+
+        outputView.printDealCards(dealerResponse, playerResponse, INITIAL_DRAW_COUNT);
+    }
+
+    private ParticipantResponse getHiddenDealerResponse(final Dealer dealer) {
+        final List<Card> hiddenCards = dealer.getCards().subList(0, INITIAL_DRAW_COUNT - 1);
+        final CardsResponse cardsResponse = new CardsResponse(-1, getCardInfos(hiddenCards));
+        return new ParticipantResponse(dealer.getName(), cardsResponse);
+    }
+
+    private List<String> getCardInfos(final List<Card> cards) {
+        return cards.stream()
+                .map(card -> card.getNumberName() + card.getSuitName())
+                .collect(Collectors.toList());
+    }
+
+    private List<ParticipantResponse> getParticipantResponses(final List<? extends Participant> participants) {
+        return participants.stream()
+                .map(this::getParticipantResponse)
+                .collect(Collectors.toList());
+    }
+
+    private ParticipantResponse getParticipantResponse(final Participant participant) {
+        final CardsResponse cardsResponse = new CardsResponse(
+                participant.getScore(), getCardInfos(participant.getCards())
+        );
+        return new ParticipantResponse(participant.getName(), cardsResponse);
+    }
+
+    private void drawCard(final List<Player> players, final Deck deck) {
+        for (final Player player : players) {
+            drawCard(player, deck);
+        }
+    }
+
+    private void drawCard(final Player player, final Deck deck) {
+        while (player.isDrawable() && inputView.readMoreDraw(player.getName())) {
+            player.drawCard(deck.draw());
+            outputView.printHandedCardsWithoutScore(getParticipantResponse(player));
+        }
+    }
+
+    private void drawCard(final Dealer dealer, final Deck deck) {
+        if (dealer.isDrawable()) {
+            dealer.drawCard(deck.draw());
+            outputView.printDealerDrawn(new DealerStateResponse(true, dealer.getMaximumDrawableScore()));
+        }
+    }
+
+    private void printResult(final Participants participants) {
+        final List<ParticipantResponse> participantResponses = getParticipantResponses(participants.getParticipants());
+        outputView.printHandedCardsWithScore(participantResponses);
+
+        final Dealer dealer = participants.getDealer();
+        final List<Player> players = participants.getPlayers();
+
+        final List<PlayerResultResponse> playerResult = getPlayerResults(dealer, players);
+        final DealerResultResponse dealerResult = getDealerResult(dealer, playerResult);
+
+        outputView.printFinalResult(dealerResult, playerResult);
+    }
+
+    private List<PlayerResultResponse> getPlayerResults(final Dealer dealer, final List<Player> players) {
+        return players.stream()
+                .map(player -> new PlayerResultResponse(player.getName(), dealer.showResult(player.getScore())))
+                .collect(Collectors.toList());
+    }
+
+    private DealerResultResponse getDealerResult(final Dealer dealer, final List<PlayerResultResponse> playerResults) {
+        final Map<Result, Integer> dealerResult = initResult();
+        for (final PlayerResultResponse playerResult : playerResults) {
+            final Result result = playerResult.getResult().reverse();
+            dealerResult.put(result, dealerResult.get(result) + 1);
+        }
+        return new DealerResultResponse(dealer.getName(), dealerResult);
+    }
+
+    private Map<Result, Integer> initResult() {
+        final Map<Result, Integer> initResult = new EnumMap<>(Result.class);
+        for (final Result result : Result.values()) {
+            initResult.put(result, 0);
+        }
+        return initResult;
+    }
+}

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

@@ -0,0 +1,28 @@
+package blackjack.domain.card;
+
+public class Card {
+
+    private final Number number;
+    private final Suit suit;
+
+    public Card(final Number number, final Suit suit) {
+        this.number = number;
+        this.suit = suit;
+    }
+
+    public boolean isAce() {
+        return number == Number.ACE;
+    }
+
+    public int getScore() {
+        return number.getScore();
+    }
+
+    public String getNumberName() {
+        return number.getName();
+    }
+
+    public String getSuitName() {
+        return suit.getName();
+    }
+}

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

@@ -0,0 +1,58 @@
+package blackjack.domain.card;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Cards {
+
+    private static final int ACE_BONUS = 10;
+    private static final int MAXIMUM_UPDATABLE_SCORE = 21;
+
+    private final List<Card> cards;
+
+    public Cards() {
+        this(new ArrayList<>());
+    }
+
+    public Cards(final List<Card> cards) {
+        this.cards = new ArrayList<>(cards);
+    }
+
+    public void addCard(final Card card) {
+        cards.add(card);
+    }
+
+    public int calculateTotalScore() {
+        final int score = getTotalScore();
+
+        if (isExistAce() && isScoreUpdatable(score)) {
+            return score + ACE_BONUS;
+        }
+
+        return score;
+    }
+
+    private int getTotalScore() {
+        return cards.stream()
+                .mapToInt(Card::getScore)
+                .sum();
+    }
+
+    private boolean isExistAce() {
+        return cards.stream()
+                .anyMatch(Card::isAce);
+    }
+
+    private boolean isScoreUpdatable(final int score) {
+        return score + ACE_BONUS <= MAXIMUM_UPDATABLE_SCORE;
+    }
+
+    public int count() {
+        return cards.size();
+    }
+
+    public List<Card> getCards() {
+        return Collections.unmodifiableList(cards);
+    }
+}

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

@@ -0,0 +1,45 @@
+package blackjack.domain.card;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Stack;
+import java.util.stream.Collectors;
+
+public class Deck {
+
+    private static final Stack<Card> TRUMP;
+
+    static {
+        final Stack<Card> pack = new Stack<>();
+        final List<Card> cards = Arrays.stream(Suit.values())
+                .flatMap(suit -> Arrays.stream(Number.values())
+                        .map(number -> new Card(number, suit))
+                )
+                .collect(Collectors.toList());
+        pack.addAll(cards);
+        TRUMP = pack;
+    }
+
+    private final Stack<Card> cards;
+
+    public Deck(final Stack<Card> cards) {
+        Collections.shuffle(cards);
+        this.cards = cards;
+    }
+
+    public static Deck createUsingTrump(final int count) {
+        final Stack<Card> pack = new Stack<>();
+        for (int i = 0; i < count; i++) {
+            pack.addAll(TRUMP);
+        }
+        return new Deck(pack);
+    }
+
+    public Card draw() {
+        if (cards.empty()) {
+            throw new IllegalStateException("덱에 더 이상의 카드가 없습니다.");
+        }
+        return cards.pop();
+    }
+}