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

README.md

@@ -5,3 +5,36 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+## 기능 요구 사항
+
+- 블랙잭 게임은 딜러와 플레이어 중 카드의 합이 21 또는 21에 가장 가까운 숫자를 가지는 쪽이 이기는 게임이다.
+- 각 카드는 점수를 가진다.
+  - 숫자 카드는 카드 숫자로 계산한다.
+  - King, Queen, Jack은 각각 10으로 계산한다.
+  - Ace는 1 또는 11로 계산한다.
+- 플레이어는 이름을 가진다.
+  - 이름은 공백으로만 구성될 수 없다.
+  - 이름은 앞뒤 공백을 가질 수 없다.
+  - 중복된 이름은 가질 수 없다.
+
+### 플레이어 승리 조건
+
+- 아래의 두 조건을 모두 만족하면 플레이어가 승리한다.
+  - 카드의 점수 합이 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,58 @@
+package blackjack;
+
+import blackjack.domain.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.printStartCards(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.printResultCardAndScore(dealer, players);
+        outputView.printDealerMatchResult(dealer.match(players));
+        for (Player player : players.getPlayers()) {
+            outputView.printPlayerMatchResult(player.getName(), player.isWin(dealer));
+        }
+    }
+}

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

@@ -0,0 +1,43 @@
+package blackjack.domain;
+
+import static java.util.stream.Collectors.toList;
+
+import blackjack.domain.card.Card;
+import blackjack.domain.card.Shape;
+import blackjack.domain.card.Value;
+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;
+
+    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/Card.java

@@ -0,0 +1,47 @@
+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;
+    }
+}

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,34 @@
+package blackjack.domain.card;
+
+public enum Value {
+    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 minScore;
+
+    Value(int minScore) {
+        this.minScore = minScore;
+    }
+
+    public int getMinScore() {
+        return minScore;
+    }
+
+    public int getMaxScore() {
+        if (this == ACE) {
+            return minScore + 10;
+        }
+        return minScore;
+    }
+}

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

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

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

@@ -0,0 +1,40 @@
+package blackjack.domain.participant;
+
+import java.util.Objects;
+
+public class Name {
+
+    private final String name;
+
+    public Name(String name) {
+        validate(name);
+        this.name = name.strip();
+    }
+
+    private void validate(String name) {
+        if (name == null || name.isBlank()) {
+            throw new IllegalArgumentException("이름은 적어도 한 글자 이상을 포함해야 합니다.");
+        }
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (this == object) {
+            return true;
+        }
+        if (object == null || getClass() != object.getClass()) {
+            return false;
+        }
+        Name name1 = (Name) object;
+        return Objects.equals(name, name1.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name);
+    }
+}

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

@@ -0,0 +1,66 @@
+package blackjack.domain.participant;
+
+import blackjack.domain.Deck;
+import blackjack.domain.card.Card;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public abstract class Participant {
+
+    protected static final int BLACKJACK_SCORE = 21;
+    private static final int START_CARDS_SIZE = 2;
+
+    private final List<Card> cards;
+
+    protected Participant(List<Card> cards) {
+        this.cards = new ArrayList<>(cards);
+    }
+
+    public final int calculateScore() {
+        int score = getMaxScore();
+        int cardIndex = 0;
+        while (score > BLACKJACK_SCORE && cardIndex < cards.size()) {
+            Card card = cards.get(cardIndex);
+            score = score + card.getMinScore() - card.getMaxScore();
+            cardIndex++;
+        }
+        return score;
+    }
+
+    private int getMaxScore() {
+        return cards.stream()
+                .mapToInt(Card::getMaxScore)
+                .sum();
+    }
+
+    public final boolean isDrawable() {
+        return calculateScore() <= getMaxDrawableScore();
+    }
+
+    public final boolean isBusted() {
+        return calculateScore() > BLACKJACK_SCORE;
+    }
+
+    public void drawStartCards(Deck deck) {
+        if (!cards.isEmpty()) {
+            throw new IllegalStateException("이미 시작 카드를 뽑았습니다.");
+        }
+        for (int i = 0; i < START_CARDS_SIZE; i++) {
+            add(deck.draw());
+        }
+    }
+
+    public final void add(Card card) {
+        if (!isDrawable()) {
+            throw new IllegalStateException("더 이상 카드를 추가할 수 없습니다.");
+        }
+        cards.add(card);
+    }
+
+    public final List<Card> getCards() {
+        return Collections.unmodifiableList(cards);
+    }
+
+    protected abstract int getMaxDrawableScore();
+}