[1단계 - 블랙잭 게임 실행] 몰리(김지민) 미션 제출합니다.

docs/README.md

@@ -0,0 +1,69 @@
+## 기능 요구 사항
+
+- [x] 참여할 사람의 이름을 입력받는다.
+- [x] 참여할 인원의 수는 최소 1명 최대 10명이다.(딜러 제외)
+
+- [x] 게임을 시작하면 플레이어는 딜러에게 두 장의 카드를 지급 받는다.
+- [x] 딜러는 2장의 카드를 받고 한 장의 카드만 공개한다.
+
+- [x] 카드를 더 받을지 선택한다.
+- [x] 21이 넘지 않은 플레이어는 추가로 카드를 더 받을지 선택할 수 있다.
+    - [x] 21이 초과된 경우 알리고 다음 플레이어의 턴으로 넘어간다.
+- [x] 카드 추가 여부 확인 시마다 해당 플레이어의 카드 현황을 보여준다.
+- [x] 카드를 더 받지 않으면 다음 플레이어에게 턴을 넘긴다.
+- [x] 모든 플레이어가 선택을 마칠 때까지 위의 과정을 반복한다.
+
+- [x] 딜러는 처음에 받은 2장의 합계가 16이하이면, 17이상이 넘을 때까지 카드를 추가로 받는다.
+
+- [x] 딜러와 플레이어의 카드, 결과를 공개한다.
+- [x] 딜러와 각 플레이어 별로 승패를 공개한다.
+
+### 플레이어
+
+- [x] 플레이어는 카드를 받을 수 있다.
+
+### 플레이어의 승리 조건
+
+#### 딜러가 21미만인 경우
+
+- [x] 플레이어 결과가 딜러보다 큰 경우
+- [x] 플레이어 결과가 딜성러의 결과와 동일하지만 카드 수는 적은 경우
+
+#### 딜러가 21인 경우
+
+- [x] 플레이어 카드만 블랙잭인 경우
+- [x] 플레이어의 카드 수가 딜러의 카드 수보다 적은 경우
+
+#### 딜러가 21 초과했을 경우
+
+- [x] 플레이어 결과가 21이하인 경우
+
+### 무승부 조건
+
+- [x] 플레이어와 딜러 모두 블랙잭인 경우
+- [x] 플레이어와 딜러의 결과, 카드 수가 모두 동일한 경우
+- [x] 플레이어와 딜러 모두 21 초과인 경우
+
+### 카드
+
+- [x] 전체 카드의 수는 52장이다.
+- [x] 카드의 종류와 개수는 아래 사진과 같다.
+  ![image](https://github.com/jminkkk/java-blackjack/assets/102847513/5e4a056f-136d-429d-b9b5-6819c2684726)
+
+- [x] Ace의 기본값은 1이다.
+    - [x] Ace를 여러 개 가진 경우 ACE는 1점으로 계산한다.
+    - [x] Ace를 제외한 나머지 카드의 합계가 10을 초과하면 ACE는 1점으로 계산한다.
+- [x] Ace를 제외한 나머지 카드의 합계가 10 이하인 경우 ACE는 11점으로 계산한다.
+- [x] King, Queen, Jack은 각각 10으로 계산한다.
+
+---
+
+## 예외처리
+
+- [x] 이름 입력 시 blank가 들어온 경우
+- [x] 이름의 수가 1개 미만인 경우
+- [x] 이름의 수가 10개 초과인 경우성
+- [x] 이름이 중복되는 경우
+
+- [x] 추가 선택 입력 시 blank가 들어온 경우
+- [x] 추가 선택 입력 시 y 또는 n이 아닌 경우

src/main/java/blackjack/Application.java

@@ -0,0 +1,12 @@
+package blackjack;
+
+public class Application {
+    public static void main(String[] args) {
+        try {
+            BlackJackGame game = new BlackJackGame();
+            game.run();
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+}

src/main/java/blackjack/BlackJackGame.java

@@ -0,0 +1,97 @@
+package blackjack;
+
+import blackjack.dto.NameCardsScore;
+import blackjack.model.participant.Dealer;
+import blackjack.model.deck.Deck;
+import blackjack.model.participant.Player;
+import blackjack.model.participant.Players;
+import blackjack.model.result.Referee;
+import blackjack.model.result.ResultCommand;
+import blackjack.model.result.Rule;
+import blackjack.util.ConsoleReader;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+import java.util.List;
+import java.util.Map;
+
+public class BlackJackGame {
+    private static final ConsoleReader CONSOLE_READER = new ConsoleReader();
+
+    public void run() {
+        final Deck deck = new Deck();
+
+        final List<String> names = InputView.readPlayerNames(CONSOLE_READER);
+        final Players players = Players.of(names, deck.distributeInitialCard(names.size()));
+
+        final Dealer dealer = new Dealer(deck.distributeInitialCard());
+        final Referee referee = new Referee(new Rule(dealer), players);
+
+        OutputView.printDistributionSubject(players.getNames());
+        printInitialCards(dealer, players);
+
+        playPlayersTurn(players.getPlayers(), deck);
+        playDealerTurn(dealer, deck);
+
+        printFinalResult(dealer, players, referee);
+    }
+
+    private void printInitialCards(final Dealer dealer, final Players players) {
+        OutputView.printNameAndCards(dealer.getName(), dealer.openCard());
+        players.collectCardsOfEachPlayer()
+                .forEach(OutputView::printNameAndCards);
+        OutputView.println();
+    }
+
+    private void playPlayersTurn(final List<Player> players, final Deck deck) {
+        for (Player player : players) {
+            playPlayerTurn(player, deck);
+        }
+    }
+
+    private void playPlayerTurn(final Player player, final Deck deck) {
+        if (!player.isBust() && player.canHit()) {
+            final boolean isHit = InputView.readHitOrNot(player.getName(), CONSOLE_READER);
+            distributeIfPlayerWant(isHit, player, deck);
+        }
+    }
+
+    private void distributeIfPlayerWant(final boolean isHit, final Player player, final Deck deck) {
+        if (isHit) {
+            distributeNewCard(player, deck);
+            OutputView.printNameAndCards(player.getName(), player.openCards());
+            playPlayerTurn(player, deck);
+        }
+    }
+
+    private void playDealerTurn(final Dealer dealer, final Deck deck) {
+        while (dealer.canHit()) {
+            OutputView.printDealerHit();
+            distributeNewCard(dealer, deck);
+        }
+    }
+
+    private void distributeNewCard(final Player player, final Deck deck) {
+        player.receiveCard(deck.distribute());
+    }
+
+    private void printFinalResult(final Dealer dealer, final Players players, final Referee referee) {
+        printFinalCardsAndScores(dealer, players);
+        printFinalResultCommand(referee);
+    }
+
+    private void printFinalCardsAndScores(final Dealer dealer, final Players players) {
+        OutputView.println();
+        NameCardsScore dealerNameCardsScore = new NameCardsScore(dealer.getName(), dealer.openCards(),
+                dealer.notifyScore());
+        List<NameCardsScore> playerNameCardsScore = players.collectFinalResults();
+        OutputView.printFinalCardsAndScore(dealerNameCardsScore);
+        OutputView.printFinalCardsAndScore(playerNameCardsScore);
+    }
+
+    private void printFinalResultCommand(final Referee referee) {
+        Map<ResultCommand, Integer> dealerResults = referee.judgeDealerResult();
+        OutputView.printDealerFinalResult(dealerResults);
+        Map<String, ResultCommand> playerResults = referee.judgePlayerResult();
+        OutputView.printFinalResult(playerResults);
+    }
+}

src/main/java/blackjack/dto/NameCardsScore.java

@@ -0,0 +1,7 @@
+package blackjack.dto;
+
+import blackjack.model.deck.Card;
+import java.util.List;
+
+public record NameCardsScore(String name, List<Card> cards, int score) {
+}

src/main/java/blackjack/model/deck/Card.java

@@ -0,0 +1,46 @@
+package blackjack.model.deck;
+
+import java.util.Objects;
+
+public class Card {
+    private final Shape shape;
+    private final Score score;
+
+    public Card(final Shape shape, final Score score) {
+        this.shape = shape;
+        this.score = score;
+    }
+
+    public boolean isAce() {
+        return score.isAce();
+    }
+
+    public int getScoreValue() {
+        return score.getValue();
+    }
+
+    public Score getScore() {
+        return score;
+    }
+
+    public Shape getShape() {
+        return shape;
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Card card = (Card) o;
+        return shape == card.shape && score == card.score;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(shape, score);
+    }
+}

src/main/java/blackjack/model/deck/Deck.java

@@ -0,0 +1,59 @@
+package blackjack.model.deck;
+
+import blackjack.model.participant.Hand;
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+public class Deck {
+    private final Deque<Card> deck;
+
+    public Deck() {
+        this.deck = makeDeck();
+    }
+
+    private static Deque<Card> makeDeck() {
+        List<Card> originDeck = Arrays.stream(Shape.values())
+                .flatMap(Deck::matchScore)
+                .collect(Collectors.toList());
+        return new ArrayDeque<>(shuffleDeck(originDeck));
+    }
+
+    private static Deque<Card> shuffleDeck(final List<Card> originDeck) {
+        Collections.shuffle(originDeck);
+        return new ArrayDeque<>(originDeck);
+    }
+
+    private static Stream<Card> matchScore(Shape shape) {
+        return Arrays.stream(Score.values())
+                .map(score -> new Card(shape, score));
+    }
+
+    public Hand distributeInitialCard() {
+        return new Hand(List.of(distribute(), distribute()));
+    }
+
+    public List<Hand> distributeInitialCard(final int playerCount) {
+        return IntStream.range(0, playerCount)
+                .mapToObj(i -> distributeInitialCard())
+                .toList();
+    }
+
+    public Card distribute() {
+        try {
+            return deck.removeFirst();
+        } catch (NoSuchElementException e) {
+            throw new NoSuchElementException("카드가 부족합니다.");
+        }
+    }
+
+    public Deque<Card> getDeck() {
+        return deck;
+    }
+}

src/main/java/blackjack/model/deck/Score.java

@@ -0,0 +1,32 @@
+package blackjack.model.deck;
+
+public enum Score {
+    ACE(1),
+    TWO(2),
+    THREE(3),
+    FOUR(4),
+    FIVE(5),
+    SIX(6),
+    SEVEN(7),
+    EIGHT(8),
+    NINE(9),
+    TEN(10),
+    KING(10),
+    QUEEN(10),
+    JACK(10),
+    ;
+
+    private final int value;
+
+    Score(final int value) {
+        this.value = value;
+    }
+
+    public boolean isAce() {
+        return this == ACE;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}

src/main/java/blackjack/model/deck/Shape.java

@@ -0,0 +1,9 @@
+package blackjack.model.deck;
+
+public enum Shape {
+    SPADE,
+    DIA,
+    CLOVER,
+    HEART,
+    ;
+}

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

@@ -0,0 +1,21 @@
+package blackjack.model.participant;
+
+import blackjack.model.deck.Card;
+import java.util.List;
+
+public class Dealer extends Player {
+    private static final int HITTABLE_THRESHOLD = 16;
+
+    public Dealer(final Hand hand) {
+        super("딜러", hand);
+    }
+
+    @Override
+    public boolean canHit() {
+        return hand.calculateScore() <= HITTABLE_THRESHOLD;
+    }
+
+    public List<Card> openCard() {
+        return List.of(hand.getFirstCard());
+    }
+}