[1단계 - 블랙잭] 연로그(권시연) 미션 제출합니다.

README.md

@@ -1,7 +1,49 @@
 # java-blackjack
 
-블랙잭 미션 저장소
+## 블랙잭 용어 정리
+- 버스트: 숫자 카드의 합이 21 초과
+- 블랙잭: 숫자 카드 합이 21 + 카드 수가 2장
+- 푸시: 딜러와 플레이어 카드 동점 (=비김)
+- 스테이: 카드를 그만 받겠다
+- 힛: 카드를 한장 더 받겠다
+
+## 구현 기능 목록
+
+- [x] 참여할 사람의 이름 입력
+    - 쉼표 기준으로 분리
+    - (e) 빈 값, 공백 불가
+    - (e) 중복 불가
+    - (e) 참가 인원은 최대 8명
+- [x] 카드 분배
+    - 딜러, 참가자에게 카드 2장씩 분배
+    - 딜러의 카드 1장 출력
+    - 참가자의 카드 2장 출력
+    - 참가자의 카드 합이 21이면 게임 종료
+- [x] 참가자 카드 추가 분배
+    - 카드 합이 21 이상인 참가자는 턴 종료
+    - 참가자 별로 한장의 카드 추가 여부를 입력 받기 (y/n)
+    - 참가자가 카드 추가 여부 입력
+        - y를 선택한 경우 카드 추가 분배
+        - n를 선택한 경우 해당 참가자의 턴 종료
+    - 참가자의 카드 목록 출력
+- [x] 딜러 카드 추가 분배
+    - 16 이하면 1장 추가 분배
+    - 17 이상이면 턴 종료
+- [x] 결과 출력
+    - 카드 목록 및 총합 출력  
+      (ex: 딜러 카드: 3다이아몬드, 9클로버, 8다이아몬드 - 결과: 20)
+    - 최종 승패 계산
+    - 최종 승패 출력
+        - 딜러 %d승 %d무 %d패 출력
+        - 참가자 승/무/패 결과 출력
+
+## 기능 요구 사항
+
+- 카드의 숫자 계산은 카드 숫자를 기본으로 하며, 예외로 Ace는 1 또는 11로 계산할 수 있으며, King, Queen, Jack은 각각 10으로 계산한다.
+- 게임을 시작하면 플레이어는 두 장의 카드를 지급 받으며, 두 장의 카드 숫자를 합쳐 21을 초과하지 않으면서 21에 가깝게 만들면 이긴다. 21을 넘지 않을 경우 원한다면 얼마든지 카드를 계속 뽑을 수 있다.
+- 딜러는 처음에 받은 2장의 합계가 16이하이면 반드시 1장의 카드를 추가로 받아야 하고, 17점 이상이면 추가로 받을 수 없다.
+- 게임을 완료한 후 각 플레이어별로 승패를 출력한다.
 
 ## 우아한테크코스 코드리뷰
 
-- [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+- [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)

src/main/java/Application.java

@@ -0,0 +1,8 @@
+import blackjack.game.ConsoleGame;
+
+public class Application {
+    public static void main(String[] args) {
+        ConsoleGame consoleGame = new ConsoleGame();
+        consoleGame.run();
+    }
+}

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

@@ -0,0 +1,51 @@
+package blackjack.domain.card;
+
+import java.util.Objects;
+
+public class Card {
+
+    private final Number number;
+    private final Suit suit;
+
+    public Card(final Number number, final Suit suit) {
+        this.number = number;
+        this.suit = suit;
+    }
+
+    public Number getDenomination() {
+        return number;
+    }
+
+    public Suit getSuit() {
+        return suit;
+    }
+
+    public int toInt() {
+        return this.number.getValue();
+    }
+
+    public boolean isAce() {
+        return number.isAce();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Card card = (Card) o;
+        return number == card.number && suit == card.suit;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(number, suit);
+    }
+
+    @Override
+    public String toString() {
+        return "Card{" +
+                "denomination=" + number +
+                ", suit=" + suit +
+                '}';
+    }
+}

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

@@ -0,0 +1,45 @@
+package blackjack.domain.card;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Stack;
+
+public class CardDistributor {
+
+    private static final String DECK_IS_EMPTY = "카드가 모두 소요됐습니다.";
+    private static final List<Card> CACHE = new ArrayList<>();
+
+    private final Stack<Card> deck = new Stack<>();
+
+    static {
+        for (Suit suit : Suit.values()) {
+            for (Number number : Number.values()) {
+                CACHE.add(new Card(number, suit));
+            }
+        }
+    }
+
+    public CardDistributor() {
+        Collections.shuffle(CACHE);
+        deck.addAll(CACHE);
+    }
+
+    public Card distribute() {
+        if (isEmpty()) {
+            throw new IllegalStateException(DECK_IS_EMPTY);
+        }
+        return deck.pop();
+    }
+
+    private boolean isEmpty() {
+        return deck.isEmpty();
+    }
+
+    @Override
+    public String toString() {
+        return "CardDistributor{" +
+                "deck=" + deck +
+                '}';
+    }
+}

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

@@ -0,0 +1,66 @@
+package blackjack.domain.card;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Cards {
+
+    private static final int ACE_ADDITIONAL_VALUE = 10;
+    protected static final int BLACKJACK_VALUE = 21;
+    protected static final int BLACKJACK_COUNT = 2;
+
+    private final List<Card> value;
+
+    public Cards(List<Card> cards) {
+        this.value = new ArrayList<>(cards);
+    }
+
+    public void add(Card card) {
+        this.value.add(card);
+    }
+
+    public Status getStatus() {
+        return Status.findStatus(this);
+    }
+
+    public int getCount() {
+        return value.size();
+    }
+
+    public int sum() {
+        int sum = value.stream()
+                .mapToInt(Card::toInt)
+                .sum();
+
+        if (canAddAddtionalValue(sum)) {
+            sum += ACE_ADDITIONAL_VALUE;
+        }
+
+        return sum;
+    }
+
+    private boolean canAddAddtionalValue(int sum) {
+        return hasAce() && !exceedBust(sum);
+    }
+
+    private boolean hasAce() {
+        return value.stream()
+                .anyMatch(Card::isAce);
+    }
+
+    private boolean exceedBust(int sum) {
+        return sum + ACE_ADDITIONAL_VALUE > BLACKJACK_VALUE;
+    }
+
+    public List<Card> getValue() {
+        return Collections.unmodifiableList(value);
+    }
+
+    @Override
+    public String toString() {
+        return "Cards{" +
+                "value=" + value +
+                '}';
+    }
+}

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

@@ -0,0 +1,38 @@
+package blackjack.domain.card;
+
+public enum Number {
+
+    ACE(1, "A"),
+    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, "J"),
+    QUEEN(10, "Q"),
+    KING(10, "K");
+
+    private final int value;
+    private final String name;
+
+    Number(int value, String name) {
+        this.value = value;
+        this.name = name;
+    }
+
+    public boolean isAce() {
+        return this == ACE;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public String getName() {
+        return name;
+    }
+}

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

@@ -0,0 +1,24 @@
+package blackjack.domain.card;
+
+import java.util.Arrays;
+import java.util.function.Predicate;
+
+public enum Status {
+    BLACKJACK((cards) -> cards.getCount() == Cards.BLACKJACK_COUNT && cards.sum() == Cards.BLACKJACK_VALUE),
+    BUST((cards) -> cards.sum() > Cards.BLACKJACK_VALUE),
+    NONE((cards) -> cards.sum() < Cards.BLACKJACK_VALUE
+            || (cards.sum() == Cards.BLACKJACK_VALUE && cards.getCount() != Cards.BLACKJACK_COUNT));
+
+    private final Predicate<Cards> condition;
+
+    Status(Predicate<Cards> condition) {
+        this.condition = condition;
+    }
+
+    public static Status findStatus(Cards cards) {
+        return Arrays.stream(Status.values())
+                .filter(status -> status.condition.test(cards))
+                .findAny()
+                .orElseThrow(() -> new IllegalArgumentException("유효하지 않은 cards 입니다."));
+    }
+}

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

@@ -0,0 +1,19 @@
+package blackjack.domain.card;
+
+public enum Suit {
+
+    CLOVER("클로버"),
+    HEART("하트"),
+    DIAMOND("다이아몬드"),
+    SPADE("스페이드");
+
+    private final String name;
+
+    Suit(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/blackjack/domain/game/BlackjackGame.java

@@ -0,0 +1,62 @@
+package blackjack.domain.game;
+
+import blackjack.domain.card.Card;
+import blackjack.domain.card.CardDistributor;
+import blackjack.domain.card.Cards;
+import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Name;
+import blackjack.domain.participant.Participant;
+import blackjack.domain.participant.Participants;
+import blackjack.domain.participant.Player;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class BlackjackGame {
+
+    public static final String DEALER_NAME = "딜러";
+    private static final int INIT_CARD_COUNT = 2;
+
+    private final Participants participants;
+    private final CardDistributor cardDistributor = new CardDistributor();
+
+    public BlackjackGame(List<Name> names) {
+        Dealer dealer = new Dealer(new Name(DEALER_NAME), drawInitialCards());
+        List<Player> players = initializePlayers(new ArrayList<>(names));
+        this.participants = new Participants(players, dealer);
+    }
+
+    private List<Player> initializePlayers(List<Name> names) {
+        return names.stream()
+                .map(name -> new Player(name, drawInitialCards()))
+                .collect(Collectors.toUnmodifiableList());
+    }
+
+    private Cards drawInitialCards() {
+        List<Card> cards = new ArrayList<>();
+        for (int i = 0; i < INIT_CARD_COUNT; i++) {
+            cards.add(cardDistributor.distribute());
+        }
+        return new Cards(cards);
+    }
+
+    public void drawCard(Participant participant) {
+        participants.drawCard(participant, cardDistributor.distribute());
+    }
+
+    public GameResult createGameResult() {
+        return new GameResult(participants.getPlayers(), participants.getDealer());
+    }
+
+    public Participants getParticipants() {
+        return participants;
+    }
+
+    @Override
+    public String toString() {
+        return "BlackjackGame{" +
+                "participants=" + participants +
+                ", cardDistributor=" + cardDistributor +
+                '}';
+    }
+}