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

README.md

@@ -5,3 +5,84 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+## 블랙잭 개요
+
+- 블랙잭 게임은 딜러와 플레이어가 진행한다.
+- 카드의 합이 21에 가장 가까운 숫자를 가지는 쪽이 이기는 게임이다.
+- 숫자 계산은 카드의 숫자를 기본으로 하되,
+  - Ace: 1 or 11
+  - King, Queen, Jack: 10
+- 게임을 시작하면, 딜러와 플레이어는 두 장의 카드를 지급받는다.
+- 플레이어는 카드 숫자의 합이 21 미만이라면 카드를 계속 뽑을 수 있다.
+- 딜러는 카드 숫자의 합이 16 이하인 경우에만 1장의 카드를 추가로 받아야 한다.
+  - 딜러는 최대 3장의 카드만 받을 수 있다.
+- 게임이 완료되면, 각 플레이어의 승패를 출력한다.
+
+## 도메인 다이어그램
+
+```mermaid
+graph TD
+    BlackJackController --> InputView
+    BlackJackController --> OutputView
+    BlackJackController --> Participants
+    BlackJackController --> Deck
+    Participants --> Participant
+    Participant --> Player
+    Participant --> Dealer
+    Participant --> Cards
+    Player --> Name
+    DeckFactory --> Deck
+    Cards --> Card
+    Card --> Suit
+    Card --> Number
+```
+
+## 기능 구현 목록
+
+### 참가자
+
+- [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] 최종 결과를 출력한다.
+- [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,118 @@
+package blackjack.controller;
+
+import blackjack.domain.card.Deck;
+import blackjack.domain.card.DeckFactory;
+import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Participant;
+import blackjack.domain.participant.Participants;
+import blackjack.domain.participant.Player;
+import blackjack.domain.result.Score;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+import blackjack.view.dto.DealerStateResponse;
+import blackjack.view.dto.ParticipantResponse;
+import blackjack.view.dto.PlayerResultResponse;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class BlackJackController {
+
+    private static final int INIT_DRAW_COUNT = 2;
+    private static final int DEALER_LIMIT = 16;
+
+    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 = gatherParticipants();
+        final Deck deck = DeckFactory.createWithCount(Deck.TRUMP, 1);
+
+        deck.shuffle();
+        dealCards(participants, deck);
+
+        cardDraw(participants.getPlayers(), deck);
+        cardDraw(participants.getDealer(), deck);
+
+        printResult(participants);
+    }
+
+    private Participants gatherParticipants() {
+        final List<Participant> participants = new ArrayList<>();
+
+        participants.add(new Dealer());
+        participants.addAll(createPlayers());
+
+        return new Participants(participants);
+    }
+
+    private List<Player> createPlayers() {
+        final List<String> playerNames = inputView.readPlayerNames();
+        return playerNames.stream()
+                .map(Player::new)
+                .collect(Collectors.toList());
+    }
+
+    private void dealCards(Participants participants, Deck deck) {
+        participants.drawCard(deck, INIT_DRAW_COUNT);
+
+        final ParticipantResponse dealerResponse = ParticipantResponse.from(participants.getDealer());
+        final List<ParticipantResponse> playerResponse = getPlayerResponse(participants.getPlayers());
+
+        outputView.printDealCards(dealerResponse, playerResponse, INIT_DRAW_COUNT);
+    }
+
+    private List<ParticipantResponse> getPlayerResponse(final List<Player> players) {
+        return players.stream()
+                .map(ParticipantResponse::from)
+                .collect(Collectors.toList());
+    }
+
+    private void cardDraw(final List<Player> players, final Deck deck) {
+        for (final Player player : players) {
+            cardDraw(player, deck);
+        }
+    }
+
+    private void cardDraw(final Player player, final Deck deck) {
+        while (player.isDrawable() && inputView.readMoreDraw(player.getName())) {
+            player.drawCard(deck.draw());
+            outputView.printHandedCardsWithoutScore(ParticipantResponse.from(player));
+        }
+    }
+
+    private void cardDraw(final Dealer dealer, final Deck deck) {
+        if (dealer.isDrawable()) {
+            dealer.drawCard(deck.draw());
+            outputView.printDealerCardDrawn(new DealerStateResponse(true, DEALER_LIMIT));
+        }
+    }
+
+    private void printResult(final Participants participants) {
+        final List<ParticipantResponse> participantResponses = getParticipantResponses(participants.getParticipants());
+        participantResponses.forEach(outputView::printHandedCardsWithScore);
+
+        final Dealer dealer = participants.getDealer();
+
+        final List<PlayerResultResponse> playerResultResponses = getPlayerResultResponses(
+                dealer.getScore(), participants.getPlayers());
+        outputView.printResult(dealer.getName(), playerResultResponses);
+    }
+
+    private List<ParticipantResponse> getParticipantResponses(final List<Participant> participants) {
+        return participants.stream()
+                .map(ParticipantResponse::from)
+                .collect(Collectors.toList());
+    }
+
+    public List<PlayerResultResponse> getPlayerResultResponses(final Score dealerScore, final List<Player> players) {
+        return players.stream()
+                .map(player -> new PlayerResultResponse(player.getName(), player.getWinningStatus(dealerScore)))
+                .collect(Collectors.toList());
+    }
+}

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,66 @@
+package blackjack.domain.card;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Cards {
+
+    private static final int MAXIMUM_SCORE = 21;
+    private static final int ACE_BONUS = 10;
+
+    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_SCORE;
+    }
+
+    public boolean isTotalScoreOver() {
+        return calculateTotalScore() > MAXIMUM_SCORE;
+    }
+
+    public boolean isMaximumScore() {
+        return calculateTotalScore() == MAXIMUM_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,36 @@
+package blackjack.domain.card;
+
+import java.util.Collections;
+import java.util.Stack;
+
+public class Deck {
+
+    public static final Stack<Card> TRUMP;
+
+    static {
+        final Stack<Card> pack = new Stack<>();
+        for (final Suit suit : Suit.values()) {
+            for (final Number number : Number.values()) {
+                pack.add(new Card(number, suit));
+            }
+        }
+        TRUMP = pack;
+    }
+
+    private final Stack<Card> cards;
+
+    public Deck(final Stack<Card> cards) {
+        this.cards = cards;
+    }
+
+    public Card draw() {
+        if (cards.empty()) {
+            throw new IllegalStateException("덱에 더 이상의 카드가 없습니다.");
+        }
+        return cards.pop();
+    }
+
+    public void shuffle() {
+        Collections.shuffle(cards);
+    }
+}

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

@@ -0,0 +1,16 @@
+package blackjack.domain.card;
+
+import java.util.Stack;
+
+public class DeckFactory {
+
+    public static Deck createWithCount(final Stack<Card> pack, int count) {
+        final Stack<Card> cards = new Stack<>();
+
+        while (count-- > 0) {
+            cards.addAll(pack);
+        }
+
+        return new Deck(cards);
+    }
+}