[2단계 - 블랙잭 베팅] 밍트(김명지) 미션 제출합니다.

README.md

@@ -8,6 +8,13 @@
 - 예외
     - [x] 중복된 이름인 경우
 
+### 베팅 금액 입력
+- [x] 베팅 금액을 입력받는다.
+- 예외
+  - [x] 숫자가 아닌 경우
+  - [x] 음수인 경우
+  - [x] 0인 경우
+
 ### 카드 2장씩 분배 후 공개
 
 - [X] 참가자별로 모두 2장씩 분배한다.
@@ -29,16 +36,22 @@
 - [x] 참가자 모두의 카드를 공개한다.
 - [x] 참가자가 지닌 카드의 합을 계산하여 공개한다.
 
-### 승패 결과 출력
+### 승패 결과 계산
 
 - [x] 딜러와 각 플레이어 사이의 승패를 계산한다.
-    - 딜러와 플레이어가 둘 다 버스트이면, 딜러 승
+    - 플레이어가 버스트이면 딜러가 버스트 여부와 상관없이, 딜러 승
     - 딜러나 플레이어 둘 중 한명이 버스트이면, 버스트가 아닌 사람이 승
     - 딜러와 플레이어가 둘 다 버스트가 아닌 상황
         - 카드 합이 같다면 무승부
         - 카드 합이 다르다면 합이 큰 사람이 승
-- [x] 딜러는 `0승 0무 0패` 형식으로 결과를 출력한다.
-- [x] 플레이어는 `승` or `무` or `패` 형식으로 결과를 출력한다.
+
+### 최종 수익 계산
+- [x] 딜러와 플레이어들의 최종 수익을 계산한다.
+  - [x] 버스트의 경우 베팅 금액을 모두 잃음
+  - [x] 버스트가 아니면서 카드 총 합이 더 크면 베팅 금액을 받음
+    - [x] 플레이어의 처음 두 장의 합이 21일 경우 블랙잭이 되어 베팅 금액의 1.5배를 딜러에게 받음
+      - [x] 딜러와 플레이어가 동시에 블랙잭인 경우(비긴 경우) 플레이어는 베팅 금액을 돌려받음
+- [x] 딜러와 플레이어들의 최종 수익 출력
 
 ## 블랙잭 도메인 용어
 - 딜러(Dealer) : 카드를 나눠주고 게임을 진행하는 역할

src/main/java/blackjack/Application.java

@@ -1,19 +1,21 @@
 package blackjack;
 
-import blackjack.controller.BlackjackController;
+import blackjack.controller.Controller;
+import blackjack.blackjack.card.Deck;
 import blackjack.view.InputView;
 import blackjack.view.ResultView;
+import java.util.Scanner;
 
-public class Application {
+public final class Application {
 
     public static void main(String[] args) {
-        final BlackjackController blackjackController = makeController();
-        blackjackController.run();
+        Controller controller = makeController();
+        controller.startGame(Deck.shuffled());
     }
 
-    private static BlackjackController makeController() {
-        final InputView inputView = new InputView();
+    private static Controller makeController() {
+        final InputView inputView = new InputView(new Scanner(System.in));
         final ResultView resultView = new ResultView();
-        return new BlackjackController(inputView, resultView);
+        return new Controller(inputView, resultView);
     }
 }

src/main/java/blackjack/blackjack/BlackjackGame.java

@@ -0,0 +1,36 @@
+package blackjack.blackjack;
+
+import blackjack.blackjack.card.Deck;
+import blackjack.blackjack.participant.Participants;
+import blackjack.blackjack.participant.Player;
+import blackjack.blackjack.result.ProfitResult;
+import java.util.ArrayDeque;
+import java.util.Queue;
+
+public final class BlackjackGame {
+
+    private final Participants participants;
+
+    private Queue<Player> players;
+
+    public BlackjackGame(final Participants participants) {
+        this.participants = participants;
+        this.players = new ArrayDeque<>(participants.findHitEligiblePlayers().getPlayers());
+    }
+
+    public boolean isPlaying() {
+        return !players.isEmpty();
+    }
+
+    public Player findCurrentTurnPlayer() {
+        return players.poll();
+    }
+
+    public ProfitResult makeProfitResult() {
+        return participants.makeDealerWinningResult();
+    }
+
+    public Participants getParticipants() {
+        return participants;
+    }
+}

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

@@ -0,0 +1,47 @@
+package blackjack.blackjack.card;
+
+import java.util.Objects;
+
+public final class Card {
+
+    private final Suit suit;
+    private final Denomination denomination;
+
+    public Card(final Suit suit, final Denomination denomination) {
+        this.suit = suit;
+        this.denomination = denomination;
+    }
+
+    public boolean isAce() {
+        return this.denomination == Denomination.A;
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (!(o instanceof final Card card)) {
+            return false;
+        }
+        return suit == card.suit && denomination == card.denomination;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(suit, denomination);
+    }
+
+    public Suit getSuit() {
+        return suit;
+    }
+
+    public String getDenominationName() {
+        return denomination.getName();
+    }
+
+    public int getCardMinNumber() {
+        return denomination.getMinNumber();
+    }
+
+    public int getCardMaxNumber() {
+        return denomination.getMaxNumber();
+    }
+}

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

@@ -0,0 +1,34 @@
+package blackjack.blackjack.card;
+
+import blackjack.blackjack.card.generator.DeckGenerator;
+import blackjack.blackjack.card.generator.ShuffleDeckGenerator;
+import blackjack.util.ExceptionMessage;
+import java.util.Deque;
+import java.util.stream.IntStream;
+
+public final class Deck {
+
+    private final Deque<Card> cards;
+
+    public Deck(final DeckGenerator deckGenerator) {
+        this.cards = deckGenerator.makeDeck();
+    }
+
+    public static Deck shuffled() {
+        return new Deck(new ShuffleDeckGenerator());
+    }
+
+    public Hand drawCardsByCount(final int count) {
+        return new Hand(IntStream.range(0, count)
+                .mapToObj(o -> drawCard())
+                .toList());
+    }
+
+    public Card drawCard() {
+        Card card = cards.pollFirst();
+        if (card == null) {
+            throw new IllegalStateException(ExceptionMessage.makeMessage("[ERROR] 카드가 더이상 없습니다."));
+        }
+        return card;
+    }
+}

src/main/java/blackjack/blackjack/card/Denomination.java

@@ -0,0 +1,48 @@
+package blackjack.blackjack.card;
+
+import java.util.Set;
+
+public enum Denomination {
+
+    A(1),
+    TWO(2),
+    THREE(3),
+    FOUR(4),
+    FIVE(5),
+    SIX(6),
+    SEVEN(7),
+    EIGHT(8),
+    NINE(9),
+    TEN(10),
+    K(10),
+    Q(10),
+    J(10);
+
+    private static final Set<Denomination> SPECIAL_CARD_SCORE = Set.of(Denomination.A, Denomination.K,
+            Denomination.Q, Denomination.J);
+    private static final int ACE_MAX_NUMBER = 11;
+
+    private final int score;
+
+    Denomination(final int score) {
+        this.score = score;
+    }
+
+    public String getName() {
+        if (SPECIAL_CARD_SCORE.contains(this)) {
+            return this.name();
+        }
+        return String.valueOf(score);
+    }
+
+    public int getMinNumber() {
+        return score;
+    }
+
+    public int getMaxNumber() {
+        if (this == A) {
+            return ACE_MAX_NUMBER;
+        }
+        return score;
+    }
+}

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

@@ -0,0 +1,118 @@
+package blackjack.blackjack.card;
+
+import blackjack.util.ExceptionMessage;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+public final class Hand {
+
+    private static final int BLACKJACK_SIZE = 2;
+    public static final int BURST_THRESHOLD = 21;
+    private static final int ACE_SUBTRACT = 10;
+
+    private final List<Card> cards;
+
+    public Hand(final List<Card> cards) {
+        this.cards = new ArrayList<>(cards);
+    }
+
+    public Hand(final Card card) {
+        this(List.of(card));
+    }
+
+    public int calculateScore() {
+        int maxScore = calculateScore(cards);
+        if (isNotBurst(maxScore)) {
+            return maxScore;
+        }
+        return subtractAce(maxScore);
+    }
+
+    public int calculateWithHardHand() {
+        return cards.stream()
+                .mapToInt(Card::getCardMinNumber)
+                .sum();
+    }
+
+    public void add(final Card card) {
+        cards.add(card);
+    }
+
+    public void addAll(final Hand givenHand) {
+        cards.addAll(givenHand.getCards());
+    }
+
+    public boolean isBlackjack() {
+        return cards.size() == BLACKJACK_SIZE && calculateScore() == BURST_THRESHOLD;
+    }
+
+    public boolean isBust() {
+        return calculateScore() > BURST_THRESHOLD;
+    }
+
+    private int calculateScore(final List<Card> cards) {
+        return cards.stream()
+                .mapToInt(Card::getCardMaxNumber)
+                .sum();
+    }
+
+    private boolean isNotBurst(final int score) {
+        return score <= BURST_THRESHOLD;
+    }
+
+    private int subtractAce(int score) {
+        int aceCount = countAce(cards);
+        while (!isNotBurst(score) && aceCount-- > 0) {
+            score -= ACE_SUBTRACT;
+        }
+        return score;
+    }
+
+    private int countAce(final List<Card> cards) {
+        return (int) cards.stream()
+                .filter(Card::isAce)
+                .count();
+    }
+
+    private void validateIndex(final int start, final int end) {
+        final int size = cards.size();
+        if (start < 0 || end < 0 || start >= size || end > size) {
+            throw new IllegalArgumentException(ExceptionMessage.makeMessage("인덱스는 0 이상 hand 크기 이하여야 합니다"));
+        }
+        if (start > end) {
+            throw new IllegalArgumentException(ExceptionMessage.makeMessage("끝 인덱스는 시작 인덱스보다 커야합니다"));
+        }
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (!(o instanceof final Hand hand1)) {
+            return false;
+        }
+        return Objects.equals(cards, hand1.cards);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(cards);
+    }
+
+    public int getSize() {
+        return cards.size();
+    }
+
+    public Card getFirstCard() {
+        return cards.getFirst();
+    }
+
+    public Hand getPartialHand(final int startInclusive, final int endExclusive) {
+        validateIndex(startInclusive, endExclusive);
+        return new Hand(cards.subList(startInclusive, endExclusive));
+    }
+
+    public List<Card> getCards() {
+        return Collections.unmodifiableList(cards);
+    }
+}

src/main/java/blackjack/blackjack/card/Suit.java

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

src/main/java/blackjack/blackjack/card/generator/DeckGenerator.java

@@ -0,0 +1,9 @@
+package blackjack.blackjack.card.generator;
+
+import blackjack.blackjack.card.Card;
+import java.util.Deque;
+
+public interface DeckGenerator {
+
+    Deque<Card> makeDeck();
+}