[2단계 - 블랙잭 베팅] 커찬(이충안) 미션 제출합니다.

README.md

@@ -5,3 +5,54 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+## 기능 요구 사항
+
+- 블랙잭 게임은 딜러와 플레이어 중 카드의 합이 21 또는 21에 가장 가까운 숫자를 가지는 쪽이 이기는 게임이다.
+- 각 카드는 점수를 가진다.
+  - 숫자 카드는 카드 숫자로 계산한다.
+  - King, Queen, Jack은 각각 10으로 계산한다.
+  - Ace는 1 또는 11로 계산한다.
+- 플레이어는 이름을 가진다.
+  - 이름은 공백으로만 구성될 수 없다.
+  - 이름은 앞뒤 공백을 가질 수 없다.
+  - 중복된 이름은 가질 수 없다.
+
+### 카드 승패에 따른 플레이어의 수익
+
+- 플레이어가 배팅 금액의 1.5배를 얻는 경우
+  - 플레이어가 '블랙잭'이고, 딜러가 블랙잭이 아닌 경우
+- 플레이어가 배팅 금액만큼 얻는 경우
+  - 플레이어가 '블랙잭'이 아니면서, 딜러보다 점수가 높은 경우
+- 플레이어의 수익이 0인 경우
+  - 플레이어, 딜러 모두 '블랙잭'인 경우
+  - 플레이어, 딜러 모두 '블랙잭'이 아니면서, 
+- 플레이러가 배팅 금액만큼 잃는 경우
+  - 
+
+#### 딜러의 수익
+
+- 플레이어가 수익을 얻는 만큼 잃는다.
+- 플레이어가 수익을 잃은 만큼 얻는다.
+- 모든 플레이어와 비교한 뒤에, 딜러가 얻은 수익들을 모두 더한다.
+
+#### 관련 용어
+
+- 블랙잭 : 카드 2장 만으로 21점을 만든 경우 (ex. A스페이드, K스페이드)
+- 버스트 : 카드 점수의 합이 21을 초과한 경우 (ex. K스페이드, K다이아몬드, 2스페이드)
+
+### 프로그램 진행 순서
+
+1. 참가자 이름 입력한다.
+2. 각 참가자의 배팅 금액을 입력받는다.
+3. 카드를 2장씩 나눠준 후에, 현재 카드 상태 출력한다. (딜러는 1장만 출력)
+4. 각 참가자들의 턴을 진행한다.
+   1. 카드가 21을 넘은 경우, 턴이 종료된다.
+   2. 카드를 더 받을 지 여부를 입력한다.
+   3. 만약 더 받는다면, 카드를 한 장 추가하고 1으로 돌아간다.
+   4. 더 받지 않을 경우, 턴을 종료한다.
+5. 딜러의 턴을 진행한다.
+   1. 카드가 16을 넘은 경우, 턴이 종료된다.
+   2. 카드를 한 장 더 추가하고, 1로 돌아간다.
+6. 딜러 및 모든 참가자의 보유 카드들과 점수를 출력한다.
+7. 딜러 및 모든 참가자의 최종 수익을 출력한다.

src/main/java/blackjack/BlackJackApplication.java

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

src/main/java/blackjack/BlackJackGame.java

@@ -0,0 +1,70 @@
+package blackjack;
+
+import blackjack.domain.card.Deck;
+import blackjack.domain.money.Profit;
+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;
+import java.util.Map;
+
+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();
+        List<Player> players = names.stream()
+                .map(name -> Player.from(name, inputView.inputBetAmount(name)))
+                .toList();
+        return new Players(players);
+    }
+
+    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) {
+        for (Player player : players.getPlayers()) {
+            playTurn(player, deck);
+        }
+        playTurn(dealer, deck);
+    }
+
+    private void playTurn(Player player, Deck deck) {
+        while (player.isDrawable() && inputView.isPlayerWantDraw(player.getName())) {
+            player.add(deck.draw());
+            outputView.printPlayerCards(player);
+        }
+    }
+
+    private void playTurn(Dealer dealer, Deck deck) {
+        while (dealer.isDrawable()) {
+            outputView.printDealerDraw();
+            dealer.add(deck.draw());
+        }
+    }
+
+    private void printResult(Dealer dealer, Players players) {
+        outputView.printEndingStatus(dealer, players);
+
+        Profit dealerProfit = dealer.calculateDealerProfit(players);
+        Map<Player, Profit> playersProfit = dealer.calculatePlayersProfit(players);
+        outputView.printMatchResult(dealerProfit, playersProfit);
+    }
+}

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

@@ -0,0 +1,60 @@
+package blackjack.domain.card;
+
+import java.util.Objects;
+import java.util.StringJoiner;
+
+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();
+    }
+
+    public boolean isAce() {
+        return value.isAce();
+    }
+
+    public Value getValue() {
+        return value;
+    }
+
+    public Shape getShape() {
+        return shape;
+    }
+
+    @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);
+    }
+
+    @Override
+    public String toString() {
+        return new StringJoiner(", ", Card.class.getSimpleName() + "[", "]")
+                .add("value=" + value)
+                .add("shape=" + shape)
+                .toString();
+    }
+}

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,69 @@
+package blackjack.domain.card;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Hand {
+
+    public 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 = List.copyOf(cards);
+    }
+
+    public Hand add(Card card) {
+        List<Card> newCards = new ArrayList<>(cards);
+        newCards.add(card);
+
+        return new Hand(newCards);
+    }
+
+    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 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/handrank/Blackjack.java

@@ -0,0 +1,29 @@
+package blackjack.domain.handrank;
+
+import blackjack.domain.card.Hand;
+
+public final class Blackjack implements HankRank {
+
+    @Override
+    public SingleMatchResult matchAtDealer(HankRank playerHandRank) {
+        if (playerHandRank.isBlackjack()) {
+            return SingleMatchResult.DRAW;
+        }
+        return SingleMatchResult.DEALER_WIN;
+    }
+
+    @Override
+    public int getScore() {
+        return Hand.BLACKJACK_SCORE;
+    }
+
+    @Override
+    public boolean isBlackjack() {
+        return true;
+    }
+
+    @Override
+    public boolean isBust() {
+        return false;
+    }
+}