[1단계 - 블랙잭 게임 실행] 커찬(이충안) 미션 제출합니다.

README.md

@@ -5,3 +5,37 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+## 기능 요구 사항
+
+- 블랙잭 게임은 딜러와 플레이어 중 카드의 합이 21 또는 21에 가장 가까운 숫자를 가지는 쪽이 이기는 게임이다.
+- 각 카드는 점수를 가진다.
+  - 숫자 카드는 카드 숫자로 계산한다.
+  - King, Queen, Jack은 각각 10으로 계산한다.
+  - Ace는 1 또는 11로 계산한다.
+- 플레이어는 이름을 가진다.
+  - 이름은 공백으로만 구성될 수 없다.
+  - 이름은 앞뒤 공백을 가질 수 없다.
+  - 중복된 이름은 가질 수 없다.
+
+### 승리 조건
+
+- 카드 숫자를 합쳐 가능한 21에 가깝게 만들면 이긴다.
+  - 처음 받은 2장 합쳐 21이 나오는 경우 블랙잭이 되며, 모든 카드조합 중에 가장 강력하다.
+  - 카드 숫자의 합이 21을 초과하게 되는 순간 '버스트'라고 하며 딜러의 결과에 관계없이 플레이어가 패배한다.
+  - 딜러와 플레이어의 점수와 블랙잭 여부가 동일한 경우, 딜러가 승리한다.
+
+### 프로그램 진행 순서
+
+1. 참가자 이름 입력한다.
+2. 카드를 2장씩 나눠준 후에, 현재 카드 상태 출력한다.
+3. 각 참가자들의 턴을 진행한다.
+   1. 카드가 21을 넘은 경우, 턴이 종료된다.
+   2. 카드를 더 받을 지 여부를 입력한다.
+   3. 만약 더 받는다면, 카드를 한 장 추가하고 1으로 돌아간다.
+   4. 더 받지 않을 경우, 턴을 종료한다.
+4. 딜러의 턴을 진행한다.
+   1. 카드가 16을 넘은 경우, 턴이 종료된다.
+   2. 카드를 한 장 더 추가하고, 1로 돌아간다.
+5. 딜러 및 모든 참가자의 보유 카드들과 점수를 출력한다.
+6. 딜러 및 모든 참가자의 승패를 출력한다.

src/main/java/blackjack/BlackJackApplication.java

@@ -0,0 +1,8 @@
+package blackjack;
+
+public class BlackJackApplication {
+    public static void main(String[] args) {
+        BlackJackGame blackJackGame = new BlackJackGame();
+        blackJackGame.run();
+    }
+}

src/main/java/blackjack/BlackJackGame.java

@@ -0,0 +1,60 @@
+package blackjack;
+
+import blackjack.domain.card.Deck;
+import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Player;
+import blackjack.domain.participant.Players;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+import java.util.List;
+
+public class BlackJackGame {
+
+    private final InputView inputView = new InputView();
+    private final OutputView outputView = new OutputView();
+
+    public void run() {
+        Deck deck = Deck.createShuffledDeck();
+        Dealer dealer = new Dealer();
+        Players players = createPlayers();
+        drawStartCards(dealer, players, deck);
+        play(players, dealer, deck);
+        printResult(dealer, players);
+    }
+
+    private Players createPlayers() {
+        List<String> names = inputView.inputPlayerNames();
+        return Players.from(names);
+    }
+
+    private void drawStartCards(Dealer dealer, Players players, Deck deck) {
+        dealer.drawStartCards(deck);
+        players.drawStartCards(deck);
+        outputView.printStartStatus(dealer, players);
+    }
+
+    private void play(Players players, Dealer dealer, Deck deck) {
+        players.play(this::playTurn, deck);
+        while (dealer.isDrawable()) {
+            outputView.printDealerDraw();
+            dealer.add(deck.draw());
+        }
+    }
+
+    private void playTurn(Player player, Deck deck) {
+        while (player.isDrawable() && inputView.isPlayerWantDraw(player.getName())) {
+            player.add(deck.draw());
+            outputView.printPlayerCards(player);
+        }
+    }
+
+    private void printResult(Dealer dealer, Players players) {
+        outputView.printEndingStatus(dealer, players);
+        int winCount = dealer.calculateWinCount(players);
+        int loseCount = dealer.calculateLoseCount(players);
+        outputView.printDealerMatchResult(winCount, loseCount);
+        for (Player player : players.getPlayers()) {
+            outputView.printPlayerMatchResult(player.getName(), player.isWin(dealer));
+        }
+    }
+}

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

@@ -0,0 +1,51 @@
+package blackjack.domain.card;
+
+import java.util.Objects;
+
+public class Card {
+
+    private final Value value;
+    private final Shape shape;
+
+    public Card(Value value, Shape shape) {
+        this.value = Objects.requireNonNull(value);
+        this.shape = Objects.requireNonNull(shape);
+    }
+
+    public int getMinScore() {
+        return value.getMinScore();
+    }
+
+    public int getMaxScore() {
+        return value.getMaxScore();
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (this == object) {
+            return true;
+        }
+        if (object == null || getClass() != object.getClass()) {
+            return false;
+        }
+        Card card = (Card) object;
+        return value == card.value && shape == card.shape;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value, shape);
+    }
+
+    public Value getValue() {
+        return value;
+    }
+
+    public Shape getShape() {
+        return shape;
+    }
+
+    public boolean isAce() {
+        return value.isAce();
+    }
+}

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

@@ -0,0 +1,40 @@
+package blackjack.domain.card;
+
+import static java.util.stream.Collectors.toList;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class Deck {
+
+    private final Queue<Card> cards;
+
+    private Deck(List<Card> cards) {
+        this.cards = new LinkedList<>(cards);
+    }
+
+    public static Deck createShuffledDeck() {
+        List<Card> cards = Arrays.stream(Shape.values())
+                .map(Deck::makeCards)
+                .flatMap(List::stream)
+                .collect(toList());
+        Collections.shuffle(cards);
+        return new Deck(cards);
+    }
+
+    private static List<Card> makeCards(Shape shape) {
+        return Arrays.stream(Value.values())
+                .map(value -> new Card(value, shape))
+                .toList();
+    }
+
+    public Card draw() {
+        if (cards.isEmpty()) {
+            throw new IllegalStateException("카드를 더 이상 뽑을 수 없습니다.");
+        }
+        return cards.poll();
+    }
+}

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

@@ -0,0 +1,67 @@
+package blackjack.domain.card;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Hand {
+
+    private static final int BLACKJACK_SCORE = 21;
+    private static final int BLACKJACK_SIZE = 2;
+
+    private final List<Card> cards;
+
+    public Hand(List<Card> cards) {
+        this.cards = new ArrayList<>(cards);
+    }
+
+    public void add(Card card) {
+        cards.add(card);
+    }
+
+    public int calculateScore() {
+        int totalMinScore = getMinScore();
+        int biggerScore = getBiggerScore();
+
+        if (biggerScore > BLACKJACK_SCORE) {
+            return totalMinScore;
+        }
+        return biggerScore;
+    }
+
+    private int getMinScore() {
+        return cards.stream()
+                .mapToInt(Card::getMinScore)
+                .sum();
+    }
+
+    private int getBiggerScore() {
+        int score = getMinScore();
+        int differenceScore = cards.stream()
+                .filter(Card::isAce)
+                .mapToInt(this::calculateDifferenceScore)
+                .findAny()
+                .orElse(0);
+        return score + differenceScore;
+    }
+
+    private int calculateDifferenceScore(Card card) {
+        return card.getMaxScore() - card.getMinScore();
+    }
+
+    public boolean isBusted() {
+        return calculateScore() > BLACKJACK_SCORE;
+    }
+
+    public boolean isBlackjack() {
+        return cards.size() == BLACKJACK_SIZE && calculateScore() == BLACKJACK_SCORE;
+    }
+
+    public List<Card> getCards() {
+        return Collections.unmodifiableList(cards);
+    }
+
+    public boolean isEmpty() {
+        return cards.isEmpty();
+    }
+}

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

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

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

@@ -0,0 +1,37 @@
+package blackjack.domain.card;
+
+public enum Value {
+    ACE(1, 11),
+    TWO(2, 2),
+    THREE(3, 3),
+    FOUR(4, 4),
+    FIVE(5, 5),
+    SIX(6, 6),
+    SEVEN(7, 7),
+    EIGHT(8, 8),
+    NINE(9, 9),
+    TEN(10, 10),
+    JACK(10, 10),
+    QUEEN(10, 10),
+    KING(10, 10);
+
+    private final int minScore;
+    private final int maxScore;
+
+    Value(int minScore, int maxScore) {
+        this.minScore = minScore;
+        this.maxScore = maxScore;
+    }
+
+    public int getMinScore() {
+        return minScore;
+    }
+
+    public int getMaxScore() {
+        return maxScore;
+    }
+
+    public boolean isAce() {
+        return this == ACE;
+    }
+}

src/main/java/blackjack/domain/participant/Dealer.java

@@ -0,0 +1,55 @@
+package blackjack.domain.participant;
+
+import blackjack.domain.card.Card;
+import java.util.Collections;
+import java.util.List;
+
+public class Dealer extends Participant {
+
+    private static final int DRAWABLE_MAX_SCORE = 16;
+    private static final int START_CARD_SIZE = 1;
+
+    public Dealer() {
+        super(Collections.emptyList());
+    }
+
+    Dealer(List<Card> cards) {
+        super(cards);
+    }
+
+    public boolean isWin(Player player) {
+        if (player.isBusted() || this.isBlackjack()) {
+            return true;
+        }
+        if (this.isBusted() || player.isBlackjack()) {
+            return false;
+        }
+        return this.calculateScore() >= player.calculateScore();
+    }
+
+    private boolean isLose(Player player) {
+        return !isWin(player);
+    }
+
+    public int calculateWinCount(Players players) {
+        return (int) players.getPlayers().stream()
+                .filter(this::isWin)
+                .count();
+    }
+
+    public int calculateLoseCount(Players players) {
+        return (int) players.getPlayers().stream()
+                .filter(this::isLose)
+                .count();
+    }
+
+    @Override
+    protected int getMaxDrawableScore() {
+        return DRAWABLE_MAX_SCORE;
+    }
+
+    @Override
+    protected int getStartCardSize() {
+        return START_CARD_SIZE;
+    }
+}