[블랙잭 - 1단계] 아토(이혜린) 미션 제출합니다.

README.md

@@ -2,6 +2,54 @@
 
 블랙잭 미션 저장소
 
-## 우아한테크코스 코드리뷰
+## 페어와 지킬 컨벤션
+1. 클래스 정의 다음 줄은 공백으로 한다.
+2. test code에 사용하는 메서드는 `static import`한다.
 
-- [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+## 요구사항
+### 카드
+- [x] 카드는 모양과 수로 이루어져 있다.
+  - [x] 모양으로는 스페이드, 다이아, 하트, 클로버가 있다.
+  - [x] 수로는 Ace, King, Queen, Jack과 2 이상 10 이하의 정수가 있다.
+- [x] 카드의 숫자 계산은 카드 숫자를 기본으로 한다.
+  - [x] Ace는 1 또는 11로 계산할 수 있다.
+  - [x] King, Queen, Jack은 각각 10으로 계산한다.
+
+### 덱
+- [x] 맨 위의 카드 한 장을 뽑는다.
+- [x] 덱에 카드가 없는 경우, 예외를 발생한다.
+
+### 플레이어
+- [x] 덱에서 카드를 한 장 뽑는다.
+- [x] 지금까지 뽑은 카드의 점수를 계산한다.
+
+### 이름
+- [x] 이름은 2글자 이상 5글자 이하이다.
+- [x] 이름은 공백으로만 구성될 수 없다.
+
+### 플레이어들
+- [x] 플레이어들의 이름은 중복될 수 없다.
+- [x] 플레이어들의 인원수는 1명 이상 10명 이하이다.
+
+### 딜러
+- [x] 플레이어의 기능을 상속한다.
+- [x] 17점 이상이 될 때까지 카드를 계속 뽑는다.
+
+### 게임 결과
+- [x] 게임 결과를 아래의 순서대로 올바르게 판단한다.
+  1. 플레이어의 점수가 21점을 초과하면 딜러가 승리한다.
+  2. 플레이어의 점수가 21점을 초과하지 않으면서 딜러의 점수가 21점을 초과하면 플레이어가 승리한다.
+  3. 딜러와 플레이어의 점수를 비교해 승패를 결정한다.
+  4. 점수가 같으면 무승부이다.
+- [x] 각 플레이어별 게임 결과를 저장한다.
+
+---
+
+### 게임 흐름
+- [x] (hit, stand) 21을 넘지 않을 경우 원한다면 카드를 계속 뽑을 수 있다.
+- [x] 게임이 시작할 때 딜러와 플레이어는 두 장의 카드를 지급 받는다.
+- [x] 플레이어의 카드는 모두에게 공개된다.
+- [x] 딜러의 두 번째 카드는 공개되지 않는다.
+- [x] 각 플레이어는 딜러와만 승패를 겨룬다.
+- [x] 딜러는 모든 플레이어와 승패를 겨룬다.
+- [x] 게임을 완료한 후 딜러를 포함한 모든 플레이어의 승패를 확인한다.

src/main/java/blackjack/BlackJackMain.java

@@ -0,0 +1,15 @@
+package blackjack;
+
+import blackjack.game.BlackJackGame;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+
+public class BlackJackMain {
+
+    public static void main(String[] args) {
+        InputView inputView = new InputView();
+        OutputView outputView = new OutputView();
+        BlackJackGame blackJackGame = new BlackJackGame(inputView, outputView);
+        blackJackGame.play();
+    }
+}

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

@@ -0,0 +1,47 @@
+package blackjack.card;
+
+import java.util.Objects;
+
+public class Card {
+
+    private final Shape shape;
+    private final Number number;
+
+    public Card(Shape shape, Number number) {
+        this.shape = shape;
+        this.number = number;
+    }
+
+    public boolean isAce() {
+        return this.number == Number.ACE;
+    }
+
+    public int getScore() {
+        return number.getScore();
+    }
+
+    public Shape getShape() {
+        return shape;
+    }
+
+    public Number getNumber() {
+        return number;
+    }
+
+    @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 && number == card.number;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(shape, number);
+    }
+}

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

@@ -0,0 +1,40 @@
+package blackjack.card;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class Deck {
+
+    private final Queue<Card> cards;
+
+    Deck(List<Card> cards) {
+        this.cards = new LinkedList<>(cards);
+    }
+
+    public static Deck createShuffledFullDeck() {
+        List<Card> cards = new LinkedList<>();
+        for (Shape shape : Shape.values()) {
+            cards.addAll(createNumberCardsOf(shape));
+        }
+        Collections.shuffle(cards);
+        return new Deck(cards);
+    }
+
+    private static List<Card> createNumberCardsOf(Shape shape) {
+        List<Card> cards = new ArrayList<>();
+        for (Number number : Number.values()) {
+            cards.add(new Card(shape, number));
+        }
+        return cards;
+    }
+
+    public Card draw() {
+        if (cards.isEmpty()) {
+            throw new IllegalStateException("[ERROR] 덱이 비어있습니다.");
+        }
+        return cards.poll();
+    }
+}

src/main/java/blackjack/card/Number.java

@@ -0,0 +1,28 @@
+package blackjack.card;
+
+public enum Number {
+
+    ACE(1),
+    TWO(2),
+    THREE(3),
+    FOUR(4),
+    FIVE(5),
+    SIX(6),
+    SEVEN(7),
+    EIGHT(8),
+    NINE(9),
+    TEN(10),
+    JACK(10),
+    QUEEN(10),
+    KING(10);
+
+    private final int score;
+
+    Number(int score) {
+        this.score = score;
+    }
+
+    int getScore() {
+        return this.score;
+    }
+}

src/main/java/blackjack/card/Shape.java

@@ -0,0 +1,9 @@
+package blackjack.card;
+
+public enum Shape {
+
+    HEART,
+    SPADE,
+    CLOVER,
+    DIAMOND
+}

src/main/java/blackjack/game/BlackJackGame.java

@@ -0,0 +1,132 @@
+package blackjack.game;
+
+import blackjack.card.Deck;
+import blackjack.player.Dealer;
+import blackjack.player.Player;
+import blackjack.player.Players;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+import java.util.List;
+
+public class BlackJackGame {
+
+    public static final int BLACKJACK_MAX_SCORE = 21;
+
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public BlackJackGame(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void play() {
+        Deck deck = Deck.createShuffledFullDeck();
+        Dealer dealer = new Dealer();
+
+        Players players = createPlayers();
+        initGame(deck, dealer, players);
+        playersDrawMore(deck, players);
+        dealerDrawMore(deck, dealer);
+
+        showCardsWithScore(dealer, players);
+        showMatchResult(dealer, players);
+    }
+
+    private Players createPlayers() {
+        outputView.printNamesRequest();
+        List<String> names = inputView.readNames();
+        Players players = new Players(names);
+        outputView.printNewLine();
+        return players;
+    }
+
+    private void initGame(Deck deck, Dealer dealer, Players players) {
+        players.initDrawCards(deck);
+        dealer.initDrawCards(deck);
+        outputView.printInitializeBlackJack(players.getNames());
+        showInitCard(dealer, players);
+    }
+
+    private void showInitCard(Dealer dealer, Players players) {
+        outputView.printDealerFirstCard(dealer.getFirstCard());
+
+        for (Player player : players.getPlayers()) {
+            outputView.printPlayerCards(player.getName(), player.getCards());
+        }
+        outputView.printNewLine();
+    }
+
+    private void playersDrawMore(Deck deck, Players players) {
+        for (Player player : players.getPlayers()) {
+            playerDrawMore(deck, player);
+        }
+        outputView.printNewLine();
+    }
+
+    private void playerDrawMore(Deck deck, Player player) {
+        Command command = askPlayerToDrawMore(player);
+        if (command == Command.NO) {
+            return;
+        }
+        player.drawCard(deck);
+        outputView.printPlayerCards(player.getName(), player.getCards());
+
+        if (player.hasDrawableScore()) {
+            playerDrawMore(deck, player);
+        }
+    }
+
+    private Command askPlayerToDrawMore(Player player) {
+        outputView.printDrawMoreCardRequest(player.getName());
+        String input = inputView.readCommand();
+        return Command.from(input);
+    }
+
+    private void dealerDrawMore(Deck deck, Dealer dealer) {
+        while (dealer.hasDrawableScore()) {
+            dealer.drawCard(deck);
+            outputView.printDealerDrawCard();
+            outputView.printNewLine();
+        }
+    }
+
+    private void showCardsWithScore(Dealer dealer, Players players) {
+        outputView.printDealerCardsWithScore(dealer.getCards(), dealer.getScore());
+        for (Player player : players.getPlayers()) {
+            outputView.printPlayerCardsWithScore(player.getName(), player.getCards(), player.getScore());
+        }
+        outputView.printNewLine();
+    }
+
+    private void showMatchResult(Dealer dealer, Players players) {
+        MatchResults matchResults = calculateMatchResults(dealer, players);
+        outputView.printResultStart();
+        showDealerResult(matchResults);
+        showPlayersResult(players, matchResults);
+    }
+
+    private MatchResults calculateMatchResults(Dealer dealer, Players players) {
+        MatchResults matchResults = new MatchResults();
+        for (Player player : players.getPlayers()) {
+            matchResults.addResult(player.getName(), player.getScore(), dealer.getScore());
+        }
+        return matchResults;
+    }
+
+    private void showDealerResult(MatchResults matchResults) {
+        outputView.printDealerResult(
+                matchResults.getResultCount(MatchResult.DEALER_WIN),
+                matchResults.getResultCount(MatchResult.TIE),
+                matchResults.getResultCount(MatchResult.PLAYER_WIN)
+        );
+    }
+
+    private void showPlayersResult(Players players, MatchResults matchResults) {
+        for (Player player : players.getPlayers()) {
+            String playerName = player.getName();
+            MatchResult result = matchResults.getResultByName(playerName);
+            outputView.printPlayerResult(playerName, result);
+        }
+    }
+}

src/main/java/blackjack/game/Command.java

@@ -0,0 +1,21 @@
+package blackjack.game;
+
+import java.util.Arrays;
+
+public enum Command {
+    YES("y"),
+    NO("n");
+
+    private final String value;
+
+    Command(String value) {
+        this.value = value;
+    }
+
+    public static Command from(String value) {
+        return Arrays.stream(values())
+                .filter(command -> command.value.equals(value))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("[ERROR] 존재하지 않는 명령어입니다."));
+    }
+}

src/main/java/blackjack/game/MatchResult.java

@@ -0,0 +1,36 @@
+package blackjack.game;
+
+public enum MatchResult {
+
+    DEALER_WIN,
+    PLAYER_WIN,
+    TIE;
+
+    public static MatchResult chooseWinner(int playerScore, int dealerScore) {
+        if (isPlayerWinningCondition(playerScore, dealerScore)) {
+            return PLAYER_WIN;
+        }
+        if (isDealerWinningCondition(playerScore, dealerScore)) {
+            return DEALER_WIN;
+        }
+        return TIE;
+    }
+
+    private static boolean isPlayerWinningCondition(int playerScore, int dealerScore) {
+        if (isBurst(playerScore)) {
+            return false;
+        }
+        return isBurst(dealerScore) || playerScore > dealerScore;
+    }
+
+    private static boolean isDealerWinningCondition(int playerScore, int dealerScore) {
+        if (isBurst(playerScore)) {
+            return true;
+        }
+        return !isBurst(dealerScore) && dealerScore > playerScore;
+    }
+
+    private static boolean isBurst(int score) {
+        return score > BlackJackGame.BLACKJACK_MAX_SCORE;
+    }
+}