[1단계 - 블랙잭 구현] 에어(김준서) 미션 제출합니다.

README.md

@@ -1,5 +1,66 @@
 # java-blackjack
 블랙잭 게임 미션 저장소
 
-## 우아한테크코스 코드리뷰
-* [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+## 기능 요구 사항
+
+### 도메인
+
+[참가자]
+- 참가자 생성
+    - [x] 쉼표 기준으로 분리
+    - [x] 이름 한 글자 이상
+    - [x] 참가 최대 인원 8명
+
+[카드]
+- [x] 카드 문양, 번호 ENUM
+- [x] 카드 문양, 번호
+
+[카드 덱]
+- [x] 서로 다른 52장의 카드를 생성
+- [x] 카드를 드로우 할 수 있다.
+
+[카드 꾸러미]
+- [x] 여러 장의 카드를 가질 수 있는 일급 컬렉션
+
+[플레이어, 딜러 - 추상 클래스]
+Person
+- [x] Player와 Dealer의 추상 클래스
+- [x] 카드를 추가할 수 있다.
+- [x] 보유한 카드를 가져올 수 있다.
+- [x] 보유한 카드로 점수를 계산할 수 있다.
+Player, Dealer
+
+[게임 결과]
+- [x] 딜러와 플레이어간의 승 패 결과
+
+### 게임 진행
+
+[카드 분배]
+- [x] 딜러와 플레이어에게 카드 2장씩 분배
+- [x] 딜러 카드는 1장만 공개
+- [x] 분배한 카드는 덱에서 제거
+
+[카드 추가]
+- 플레이어에게 카드를 더 받을 지 물어보기
+    - [x] 입력은 y나 n 둘 중 하나
+    - 카드 합에 따라 달라진다.
+        - y : [x] 새로운 카드를 뽑기, 현재 보유 카드 출력
+        - n : [x] 현재 보유 카드 출력
+- [x] 딜러의 카드 합이 16이하면 17이상이 될 때까지 카드 추가
+
+[게임 결과]
+- 딜러와 플레이어가 가진 카드와 합 출력
+    - [x] Ace 카드는 1이나 11으로 계산
+        - [x] 21을 넘지 않는 선에서 21에 가깝게 계산
+    - [x] K,Q,J는 10으로 계산
+- 최종 승패 출력
+    - 각 플레이어와 딜러 점수 비교
+        - 플레이어 승
+            - [x] 플레이어 카드 합이 21이 넘지 않으면서 딜러보다 높은 경우
+            - [x] 딜러 카드 합이 21을 넘고 플레이어 카드합이 21을 넘지 않은 경우
+        - 딜러 승
+            - [x] 딜러 카드 합이 21이 넘지 않으면서 플레이어보다 21에 가까운 경우
+            - [x] 플레이어 카드 합이 21을 넘는 경우
+        - 무승부
+            - [x] 딜러와 플레이어 카드 합이 둘다 21을 넘는 경우
+            - [x] 딜러와 플레이어 카드 합이 같은 경우

src/ToDo.md

@@ -0,0 +1,6 @@
+# ToDo
+생성자 -> 정적 팩토리 메서드
+Score 계산 depth와 stream 변경 리펙토링!!
+
+# Done
+List<Card> cards -> Cards 일급컬렉션

src/main/java/blackjack/Application.java

@@ -0,0 +1,10 @@
+package blackjack;
+
+import blackjack.controller.BlackJackGame;
+
+public class Application {
+    public static void main(String[] args) {
+        BlackJackGame blackJackGame = new BlackJackGame();
+        blackJackGame.start();
+    }
+}

src/main/java/blackjack/controller/BlackJackGame.java

@@ -0,0 +1,110 @@
+package blackjack.controller;
+
+import blackjack.domain.card.Card;
+import blackjack.domain.card.CardDeck;
+import blackjack.domain.card.Cards;
+import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Nickname;
+import blackjack.domain.participant.Player;
+import blackjack.domain.participant.Players;
+import blackjack.domain.result.BlackJackResult;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class BlackJackGame {
+    public void start() {
+        try {
+            Players players = registerPlayers();
+            Dealer dealer = new Dealer();
+            CardDeck cardDeck = cardDeckSetting();
+            distributeCards(players, dealer, cardDeck);
+            playersTurn(players, cardDeck);
+            dealerTurn(dealer, cardDeck);
+            showResult(players, dealer);
+        } catch (IllegalStateException e) {
+            OutputView.printError(e.getMessage());
+        }
+    }
+
+    private Players registerPlayers() {
+        try {
+            OutputView.enterPlayersName();
+            List<String> allPlayersName = InputView.inputName();
+            return new Players(generatePlayers(allPlayersName));
+        } catch (IllegalArgumentException e) {
+            OutputView.printError(e.getMessage());
+            return registerPlayers();
+        }
+    }
+
+    private List<Player> generatePlayers(List<String> allPlayersName) {
+        return allPlayersName.stream()
+                .map(Nickname::new)
+                .map(Player::new)
+                .collect(Collectors.toList());
+    }
+
+    private CardDeck cardDeckSetting() {
+        Cards deck = new Cards(Card.values());
+        CardDeck cardDeck = new CardDeck(deck);
+        cardDeck.shuffleCard();
+        return cardDeck;
+    }
+
+    private void distributeCards(Players players, Dealer dealer, CardDeck cardDeck) {
+        dealer.firstDraw(cardDeck.drawCard(), cardDeck.drawCard());
+        players.eachPlayerFirstDraw(cardDeck);
+        OutputView.distributeFirstTwoCard(players.toPlayersDto(), dealer.toParticipantDto());
+    }
+
+    private void playersTurn(Players players, CardDeck cardDeck) {
+        for (Player player : players.getPlayers()) {
+            eachPlayerTurn(cardDeck, player);
+        }
+    }
+
+    private void eachPlayerTurn(CardDeck cardDeck, Player player) {
+        while (player.canDraw() && askDrawCard(player)) {
+            player.draw(cardDeck.drawCard());
+            OutputView.showCards(player.toParticipantDto());
+        }
+    }
+
+    private boolean askDrawCard(Player player) {
+        try {
+            OutputView.askOneMoreCard(player.toParticipantDto());
+            boolean wantDraw = InputView.inputAnswer();
+            playerWantStopDraw(player, wantDraw);
+            return wantDraw;
+        } catch (IllegalArgumentException e) {
+            OutputView.printError(e.getMessage());
+            return askDrawCard(player);
+        }
+    }
+
+    private void playerWantStopDraw(Player player, boolean wantDraw) {
+        if (!wantDraw) {
+            OutputView.showCards(player.toParticipantDto());
+            player.stay();
+        }
+    }
+
+    private void dealerTurn(Dealer dealer, CardDeck cardDeck) {
+        while (dealer.canDraw()) {
+            dealer.draw(cardDeck.drawCard());
+            OutputView.dealerReceiveOneCard();
+        }
+        if (!dealer.isBust() && dealer.isHit()) {
+            dealer.stay();
+        }
+    }
+
+    private void showResult(Players players, Dealer dealer) {
+        OutputView.showAllCards(players.toPlayersDto(), dealer.toParticipantDto());
+        BlackJackResult blackJackResult = new BlackJackResult(players.verifyResultByCompareScore(dealer));
+        OutputView.showFinalResult(blackJackResult.toDealerResultDto(), blackJackResult.toPlayersResultDto());
+    }
+}

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

@@ -0,0 +1,59 @@
+package blackjack.domain.card;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class Card {
+    private static final List<Card> CACHE;
+
+    static {
+        CACHE = Arrays.stream(Denomination.values())
+                .flatMap(denomination -> Arrays.stream(Shape.values())
+                        .map(shape -> new Card(shape, denomination)))
+                .collect(Collectors.toList());
+    }
+
+    private final Shape shape;
+    private final Denomination denomination;
+
+    public Card(Shape shape, Denomination denomination) {
+        this.shape = shape;
+        this.denomination = denomination;
+    }
+
+    public boolean isAce() {
+        return this.denomination.isAce();
+    }
+
+    public int addScore(int score) {
+        return denomination.addScore(score);
+    }
+
+    public static List<Card> values() {
+        return Collections.unmodifiableList(CACHE);
+    }
+
+    public Denomination getDenomination() {
+        return this.denomination;
+    }
+
+    public Shape getShape() {
+        return this.shape;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Card card = (Card) o;
+        return shape == card.shape && denomination == card.denomination;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(shape, denomination);
+    }
+}

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

@@ -0,0 +1,17 @@
+package blackjack.domain.card;
+
+public class CardDeck {
+    private final Cards deck;
+
+    public CardDeck(Cards deck) {
+        this.deck = deck;
+    }
+
+    public Card drawCard() {
+        return deck.draw();
+    }
+
+    public void shuffleCard() {
+        deck.shuffle();
+    }
+}

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

@@ -0,0 +1,97 @@
+package blackjack.domain.card;
+
+import java.util.*;
+
+import static blackjack.domain.state.BlackJack.BLACKJACK_NUMBER;
+
+public class Cards {
+    private static final String NO_REMAIN_CARD_ERROR_MESSAGE = "남은 카드가 없습니다.";
+    private static final String DUPLICATE_CARD_ERROR_MESSAGE = "중복된 카드는 존재할 수 없습니다.";
+    private static final int DEALER_DRAW_CONDITION = 16;
+    public static final int TOP_CARD = 0;
+
+    private final List<Card> cards;
+
+    public Cards(Card... cards) {
+        this(Arrays.asList(cards));
+    }
+
+    public Cards(List<Card> cards) {
+        this.cards = new ArrayList<>(cards);
+    }
+
+    public void addCard(Card card) {
+        if (cards.contains(card)) {
+            throw new IllegalStateException(DUPLICATE_CARD_ERROR_MESSAGE);
+        }
+        cards.add(card);
+    }
+
+    public Card draw() {
+        if (cards.size() == 0) {
+            throw new IndexOutOfBoundsException(NO_REMAIN_CARD_ERROR_MESSAGE);
+        }
+        return cards.remove(TOP_CARD);
+    }
+
+    public void shuffle() {
+        Collections.shuffle(cards);
+    }
+
+    public boolean isBlackJack() {
+        return calculateScore() == BLACKJACK_NUMBER;
+    }
+
+    public boolean isBust() {
+        return calculateScore() > BLACKJACK_NUMBER;
+    }
+
+    public boolean isStay() {
+        return cards.size() > 2 && isBlackJack();
+    }
+
+    public boolean isWin(Cards cards) {
+        return calculateScore() > cards.calculateScore();
+    }
+
+    public boolean isDraw(Cards cards) {
+        return calculateScore() == cards.calculateScore();
+    }
+
+    public boolean lessThanSixteen() {
+        return calculateScore() <= DEALER_DRAW_CONDITION;
+    }
+
+    public int calculateScore() {
+        int score = calculateTotalScore();
+        long aceCount = cards.stream()
+                .filter(Card::isAce)
+                .count();
+        return Denomination.plusRemainAceScore(score, aceCount);
+    }
+
+    public int calculateTotalScore() {
+        int score = 0;
+        for (Card card : cards) {
+            score = card.addScore(score);
+        }
+        return score;
+    }
+
+    public List<Card> getCards() {
+        return Collections.unmodifiableList(cards);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Cards cards1 = (Cards) o;
+        return Objects.equals(cards, cards1.cards);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(cards);
+    }
+}