[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,40 @@
+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 void dealInitialCards(final Deck deck) {
+        participants.dealInitialCards(deck);
+    }
+
+    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/domain/card/Hand.java → src/main/java/blackjack/blackjack/card/Hand.java

@@ -1,22 +1,29 @@
-package blackjack.domain.card;
+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 class Hand {
+public final class Hand {
 
     public static final int BURST_THRESHOLD = 21;
     private static final int ACE_SUBTRACT = 10;
+    private static final int BLACKJACK_SIZE = 2;
+    private static final int DEALER_THRESHOLD = 16;
 
     private final List<Card> hand;
 
     public Hand(final List<Card> hand) {
         this.hand = new ArrayList<>(hand);
     }
 
-    public int calculateResult() {
+    public Hand(final Card card) {
+        this(List.of(card));
+    }
+
+    public int calculateScore() {
         int maxScore = calculateMaxScore(hand);
         if (isNotBurst(maxScore)) {
             return maxScore;
@@ -30,10 +37,31 @@ public int calculateWithHardHand() {
                 .sum();
     }
 
+    public void add(final Card card) {
+        hand.add(card);
+    }
+
     public void addAll(final Hand givenHand) {
         hand.addAll(givenHand.getHand());
     }
 
+    public boolean isBlackjack() {
+        return hand.size() == BLACKJACK_SIZE && calculateScore() == BURST_THRESHOLD;
+    }
+
+    public boolean isBust() {
+        return calculateScore() > BURST_THRESHOLD;
+    }
+
+    public boolean isDealerStay() {
+        return calculateScore() > DEALER_THRESHOLD;
+    }
+
+    public Hand subHand(final int startInclusive, final int endExclusive) {
+        validateIndex(startInclusive, endExclusive);
+        return new Hand(hand.subList(startInclusive, endExclusive));
+    }
+
     private int calculateMaxScore(final List<Card> cards) {
         return cards.stream()
                 .mapToInt(Card::getCardMaxNumber)
@@ -58,6 +86,16 @@ private int countAce(final List<Card> cards) {
                 .count();
     }
 
+    private void validateIndex(final int start, final int end) {
+        final int size = hand.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)) {
@@ -71,19 +109,15 @@ public int hashCode() {
         return Objects.hashCode(hand);
     }
 
-    public List<Card> getHand() {
-        return Collections.unmodifiableList(hand);
-    }
-
-    public Hand getPartialCards(int start, int end) {
-        return new Hand(hand.subList(start, end));
+    public int getSize() {
+        return hand.size();
     }
 
     public Card getFirstCard() {
         return hand.getFirst();
     }
 
-    public int getSize() {
-        return hand.size();
+    public List<Card> getHand() {
+        return Collections.unmodifiableList(hand);
     }
 }

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();
+}

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

@@ -0,0 +1,30 @@
+package blackjack.blackjack.card.generator;
+
+import blackjack.blackjack.card.Card;
+import blackjack.blackjack.card.Denomination;
+import blackjack.blackjack.card.Suit;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.List;
+
+public final class ShuffleDeckGenerator implements DeckGenerator {
+
+    private static final List<Card> INITIAL_CARDS;
+
+    static {
+        INITIAL_CARDS = Arrays.stream(Suit.values())
+                .flatMap(suit -> Arrays.stream(Denomination.values())
+                        .map(cardScore -> new Card(suit, cardScore)))
+                .toList();
+    }
+
+    @Override
+    public Deque<Card> makeDeck() {
+        final List<Card> cards = new ArrayList<>(INITIAL_CARDS);
+        Collections.shuffle(cards);
+        return new ArrayDeque<>(cards);
+    }
+}