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

README.md

@@ -1,3 +1,49 @@
 # java-blackjack
 
-블랙잭 미션 저장소
+## 기능목록
+
+### 이름 입력
+
+- [x] 이름들을 입력받는다.
+- 예외
+    - [x] 중복된 이름인 경우
+
+### 카드 2장씩 분배 후 공개
+
+- [X] 참가자별로 모두 2장씩 분배한다.
+- [X] 딜러는 첫 번째 카드만 공개한다.
+- [X] 플레이어는 두 장 모두 공개한다.
+
+### 참가자 카드 추가 분배
+
+- [x] 플레이어의 카드 총합이 21미만인 경우, 한 장 더 받을 지 물어본다.
+    - [x] y 의 경우, 한 장 더 분배한다.
+        - [x] 지금까지 받은 카드를 공개한다.
+    - [x] n 의 경우, 턴을 종료한다.
+- [x] 딜러는 카드의 합을 계산한다.
+    - [x] 16 이하의 경우, 한 장 더 분배한다.
+    - [x] 17 이상의 경우, 턴을 종료한다.
+
+### 참가자 카드 공개
+
+- [x] 참가자 모두의 카드를 공개한다.
+- [x] 참가자가 지닌 카드의 합을 계산하여 공개한다.
+
+### 승패 결과 출력
+
+- [x] 딜러와 각 플레이어 사이의 승패를 계산한다.
+    - 딜러와 플레이어가 둘 다 버스트이면, 딜러 승
+    - 딜러나 플레이어 둘 중 한명이 버스트이면, 버스트가 아닌 사람이 승
+    - 딜러와 플레이어가 둘 다 버스트가 아닌 상황
+        - 카드 합이 같다면 무승부
+        - 카드 합이 다르다면 합이 큰 사람이 승
+- [x] 딜러는 `0승 0무 0패` 형식으로 결과를 출력한다.
+- [x] 플레이어는 `승` or `무` or `패` 형식으로 결과를 출력한다.
+
+## 블랙잭 도메인 용어
+- 딜러(Dealer) : 카드를 나눠주고 게임을 진행하는 역할
+- 핸드(Hand) : 플레이어나 딜러가 받은 카드 세트
+- 히트(Hit) : 추가 카드를 요청하는 행동
+- 버스트(Bust) : 카드 합계가 21을 초과하여 패배하는 상황
+- 푸시(Push) : 플레이어와 딜러의 점수가 같아 비기는 상황
+- 하드 핸드(Hard Hand) : 에이스가 없거나 에이스를 1로만 계산해야 하는 핸드

src/main/java/blackjack/Application.java

@@ -0,0 +1,19 @@
+package blackjack;
+
+import blackjack.controller.BlackjackController;
+import blackjack.view.InputView;
+import blackjack.view.ResultView;
+
+public class Application {
+
+    public static void main(String[] args) {
+        final BlackjackController blackjackController = makeController();
+        blackjackController.run();
+    }
+
+    private static BlackjackController makeController() {
+        final InputView inputView = new InputView();
+        final ResultView resultView = new ResultView();
+        return new BlackjackController(inputView, resultView);
+    }
+}

src/main/java/blackjack/controller/BlackjackController.java

@@ -0,0 +1,102 @@
+package blackjack.controller;
+
+import blackjack.domain.DealerWinningResult;
+import blackjack.domain.card.Deck;
+import blackjack.domain.card.Hand;
+import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Gamer;
+import blackjack.domain.participant.Player;
+import blackjack.domain.participant.Players;
+import blackjack.domain.shuffle.ShuffleCardGenerator;
+import blackjack.util.StringParser;
+import blackjack.view.InputView;
+import blackjack.view.ResultView;
+import java.util.List;
+import java.util.Map;
+
+public class BlackjackController {
+
+    private static final int DEALER_COUNT = 1;
+    private static final int SPREAD_CARD_SIZE_PER_PLAYER = 2;
+    private static final int SPREAD_SIZE = 1;
+
+    private static final String YES = "y";
+    private static final String NO = "n";
+
+    private final InputView inputView;
+    private final ResultView resultView;
+
+    public BlackjackController(InputView inputView, ResultView resultView) {
+        this.inputView = inputView;
+        this.resultView = resultView;
+    }
+
+    public void run() {
+        final Deck deck = new Deck(new ShuffleCardGenerator());
+        final Dealer dealer = Dealer.createEmpty();
+        final Players players = makePlayers();
+
+        spreadInitialCards(dealer, players, deck);
+        spreadExtraCards(dealer, players, deck);
+        showParticipantScore(dealer, players);
+        showWinningResult(dealer, players);
+    }
+
+    private void showParticipantScore(final Dealer dealer, final Players players) {
+        resultView.makeParticipantsWithScoreMessage(Map.entry(dealer.getNickname(), dealer.showAllCards()),
+                players.showTotalCards());
+    }
+
+    private Players makePlayers() {
+        String names = inputView.readNames();
+        List<String> parsedNames = StringParser.parseByComma(names);
+        return new Players(parsedNames.stream()
+                .map(Player::createEmpty)
+                .toList());
+    }
+
+    private void spreadInitialCards(final Dealer dealer, final Players players, final Deck deck) {
+        final int cardsCount = (DEALER_COUNT + players.getSize()) * SPREAD_CARD_SIZE_PER_PLAYER;
+        final Hand hand = deck.spreadCards(cardsCount);
+        dealer.receiveCards(hand.getPartialCards(0, SPREAD_CARD_SIZE_PER_PLAYER));
+        players.receiveCards(hand.getPartialCards(SPREAD_CARD_SIZE_PER_PLAYER, hand.getSize()),
+                SPREAD_CARD_SIZE_PER_PLAYER);
+
+        resultView.printSpreadCard(players.getNames(), Map.entry(dealer.getNickname(), dealer.showInitialCards()),
+                players.showTotalInitialCards());
+    }
+
+    private void spreadExtraCards(final Dealer dealer, final Players players, final Deck deck) {
+        Players availablePlayers = players.findHitAvailablePlayers();
+        for (Gamer gamer : availablePlayers.getPlayers()) {
+            while (gamer.canHit() && wantHit(gamer)) {
+                final Hand hand = deck.spreadCards(SPREAD_SIZE);
+                gamer.receiveCards(new Hand(List.of(hand.getFirstCard())));
+                resultView.printParticipantTotalCards(gamer.getNickname(), gamer.showAllCards());
+            }
+        }
+        while (dealer.canHit()) {
+            final Hand hand = deck.spreadCards(SPREAD_SIZE);
+            dealer.receiveCards(new Hand(List.of(hand.getFirstCard())));
+            resultView.printDealerExtraCard();
+        }
+    }
+
+    private boolean wantHit(final Gamer player) {
+        String answer = inputView.askHit(player);
+        if (isValidAnswer(answer)) {
+            return answer.equals(YES);
+        }
+        resultView.showln("잘못된 응답입니다. 다시 입력해주세요.");
+        return wantHit(player);
+    }
+
+    private boolean isValidAnswer(final String answer) {
+        return answer.equals(YES) || answer.equals(NO);
+    }
+
+    private void showWinningResult(final Dealer dealer, final Players players) {
+        final DealerWinningResult result = dealer.makeDealerWinningResult(players.calculateScores());
+        resultView.showDealerWinningResult(result);
+    }
+}

src/main/java/blackjack/domain/DealerWinningResult.java

@@ -0,0 +1,41 @@
+package blackjack.domain;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class DealerWinningResult {
+
+    private final Map<String, ResultStatus> result;
+
+    public DealerWinningResult(final Map<String, ResultStatus> result) {
+        this.result = new HashMap<>(result);
+    }
+
+    public int countResultStatus(final ResultStatus input) {
+        return (int) result.values().stream()
+                .filter(resultStatus -> resultStatus == input)
+                .count();
+    }
+
+    public Map<String, ResultStatus> makePlayerWinningResult() {
+        return result.entrySet().stream()
+                .collect(Collectors.toMap(Entry::getKey,
+                        entry -> entry.getValue().makeOppositeResult()));
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (!(o instanceof final DealerWinningResult that)) {
+            return false;
+        }
+        return Objects.equals(result, that.result);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(result);
+    }
+}

src/main/java/blackjack/domain/ResultStatus.java

@@ -0,0 +1,45 @@
+package blackjack.domain;
+
+import static blackjack.domain.card.Hand.BURST_THRESHOLD;
+
+public enum ResultStatus {
+
+    WIN,
+    LOSE,
+    PUSH;
+
+    public static ResultStatus calculateResultStatus(final int score, final int comparedScore) {
+        if (score <= BURST_THRESHOLD) {
+            return calculateResultStatusUnderBlackjackNumber(score, comparedScore);
+        }
+        return WIN;
+    }
+
+    private static ResultStatus calculateResultStatusUnderBlackjackNumber(final int score, final int comparedScore) {
+        if (comparedScore <= BURST_THRESHOLD) {
+            return calculateResultStatusBothUnderBlackjackNumber(score, comparedScore);
+        }
+        return LOSE;
+    }
+
+    private static ResultStatus calculateResultStatusBothUnderBlackjackNumber(final int score,
+                                                                              final int comparedScore) {
+        if (score > comparedScore) {
+            return LOSE;
+        }
+        if (score == comparedScore) {
+            return PUSH;
+        }
+        return WIN;
+    }
+
+    public ResultStatus makeOppositeResult() {
+        if (this == WIN) {
+            return LOSE;
+        }
+        if (this == LOSE) {
+            return WIN;
+        }
+        return PUSH;
+    }
+}

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 Shape shape;
+    private final CardScore cardScore;
+
+    public Card(final Shape shape, final CardScore cardScore) {
+        this.shape = shape;
+        this.cardScore = cardScore;
+    }
+
+    public boolean isAce() {
+        return this.cardScore == CardScore.A;
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (!(o instanceof final Card card)) {
+            return false;
+        }
+        return shape == card.shape && cardScore == card.cardScore;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(shape, cardScore);
+    }
+
+    public Shape getShape() {
+        return shape;
+    }
+
+    public String getCardScoreName() {
+        return cardScore.getName();
+    }
+
+    public int getCardMinNumber() {
+        return cardScore.getMinNumber();
+    }
+
+    public int getCardMaxNumber() {
+        return cardScore.getMaxNumber();
+    }
+}

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

@@ -0,0 +1,47 @@
+package blackjack.domain.card;
+
+import java.util.Collections;
+import java.util.List;
+
+public enum CardScore {
+
+    A(List.of(1, 11)),
+    TWO(List.of(2)),
+    THREE(List.of(3)),
+    FOUR(List.of(4)),
+    FIVE(List.of(5)),
+    SIX(List.of(6)),
+    SEVEN(List.of(7)),
+    EIGHT(List.of(8)),
+    NINE(List.of(9)),
+    TEN(List.of(10)),
+    K(List.of(10)),
+    Q(List.of(10)),
+    J(List.of(10));
+
+    private static final List<CardScore> SPECIAL_CARD_SCORE = List.of(CardScore.A, CardScore.K,
+            CardScore.Q, CardScore.J);
+
+    private final List<Integer> scores;
+
+    CardScore(final List<Integer> scores) {
+        this.scores = scores;
+    }
+
+    public String getName() {
+        final boolean isSpecialCardScore = SPECIAL_CARD_SCORE.stream()
+                .anyMatch(cardScore -> cardScore == this);
+        if (isSpecialCardScore) {
+            return this.name();
+        }
+        return String.valueOf(scores.getFirst());
+    }
+
+    public int getMinNumber() {
+        return Collections.min(scores);
+    }
+
+    public int getMaxNumber() {
+        return Collections.max(scores);
+    }
+}

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

@@ -0,0 +1,19 @@
+package blackjack.domain.card;
+
+import blackjack.domain.shuffle.CardGenerator;
+import java.util.stream.IntStream;
+
+public class Deck {
+
+    private final CardGenerator cardGenerator;
+
+    public Deck(final CardGenerator cardGenerator) {
+        this.cardGenerator = cardGenerator;
+    }
+
+    public Hand spreadCards(final int count) {
+        return new Hand(IntStream.range(0, count)
+                .mapToObj(o -> cardGenerator.pickCard())
+                .toList());
+    }
+}