[1단계 - 블랙잭] 기론(김규철) 미션 제출합니다.

README.md

@@ -5,3 +5,29 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+## 기능 요구 사항
+### 입력
+ - 참가자의 이름 입력받는 기능
+   - [예외] 입력이 null일떄
+   - [예외] 입력이 비어있을때
+ - 참가자에게 카드를 더 받겠는지 묻는 기능
+   - [예외] y,n이 아닌경우
+
+### 출력
+ - 참가자 이름들 출력 기능
+ - 딜러 및 참가자들이 가지고 있는 카드 출력
+ - 딜러의 승패 및 참가자들 승패 여부 출력
+
+### 계산
+ - 딜러 카드 숫자 합 계산 : 16이하이면 카드를 더 받는다는 메시지 출력
+ - 참가자들이 가지고 있는 카드들의 합 계산 기능
+
+### 카드 배분
+ - 딜러와 참가자들 2장씩 카드 나눠 갖도록 기능 구현
+
+### 참가자
+ - 카드를 더 받을지 선택하는 기능
+ - 카드의 합이 21을 넘어갈 경우 딜러에게 패배한다.
+ - 
+

src/main/java/blackJack/Application.java

@@ -0,0 +1,12 @@
+package blackJack;
+
+import blackJack.controller.BlackjackController;
+
+public class Application {
+    public static void main(String[] args) {
+        BlackjackController blackjackController = new BlackjackController();
+        blackjackController.run();
+
+    }
+
+}

src/main/java/blackJack/controller/BlackjackController.java

@@ -0,0 +1,59 @@
+package blackJack.controller;
+
+import blackJack.domain.Card.CardFactory;
+import blackJack.domain.User.Dealer;
+import blackJack.domain.User.Player;
+import blackJack.domain.User.Players;
+import blackJack.dto.DealerResultDto;
+import blackJack.dto.PlayerResultsDto;
+import blackJack.dto.UserDto;
+import blackJack.view.InputView;
+import blackJack.view.OutputView;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class BlackjackController {
+
+    public void run() {
+        CardFactory cardFactory = new CardFactory();
+        List<String> inputPlayerNames = InputView.inputPlayerNames();
+        Dealer dealer = new Dealer(cardFactory.initCards());
+        Players players = Players.create(inputPlayerNames, cardFactory);
+        OutputView.printDrawMessage(inputPlayerNames);
+        OutputView.printTotalUserCards(convertToUserDtos(dealer, players));
+
+        OutputView.printTotalResult(playGame(dealer, players, cardFactory));
+
+        Map<String, String> statistics = players.getStatistics(dealer);
+        OutputView.printFinalResult(PlayerResultsDto.from(statistics), DealerResultDto.from(statistics));
+    }
+
+    private List<UserDto> playGame(Dealer dealer, Players players, CardFactory cardFactory) {
+
+        players.getPlayers()
+                .forEach(player -> askOneMoreCard(player, cardFactory));
+        while (dealer.hit(cardFactory)) {
+            OutputView.printAddDealerCard();
+        }
+        return convertToUserDtos(dealer, players);
+
+    }
+
+    private void askOneMoreCard(Player player, CardFactory cardFactory) {
+        while (!player.isBust() && InputView.askOneMoreCard(player.getName())) {
+            player.hit(cardFactory);
+            OutputView.printPlayerCard(UserDto.from(player));
+        }
+    }
+
+    private List<UserDto> convertToUserDtos(Dealer dealer, Players players) {
+        List<UserDto> userDtos = new ArrayList<>();
+        userDtos.add(UserDto.from(dealer));
+        players.getPlayers().stream()
+                .map(UserDto::from)
+                .forEach(userDtos::add);
+        return userDtos;
+    }
+}

src/main/java/blackJack/domain/Card/Card.java

@@ -0,0 +1,71 @@
+package blackJack.domain.Card;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+import static blackJack.utils.ExeptionMessage.EMPTY_CARD;
+
+public class Card {
+    private static final int TOTAL_CARDS_SIZE = 52;
+    private static final List<Card> CACHE = new ArrayList<>(TOTAL_CARDS_SIZE);
+
+    private final Shape shape;
+    private final Number number;
+
+    static {
+        Arrays.stream(Shape.values())
+                .forEach(shape -> Arrays.stream(Number.values())
+                        .map(number -> new Card(shape, number))
+                        .forEach(CACHE::add));
+    }
+
+    public Card(Shape shape, Number number) {
+        this.shape = shape;
+        this.number = number;
+    }
+
+    public static Card valueOf(Shape shape, Number number) {
+        return CACHE.stream().filter(card -> card.isSameShape(shape) && card.isSameNumber(number))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException(EMPTY_CARD));
+    }
+
+    public Shape getShape() {
+        return shape;
+    }
+
+    public Number getNumber() {
+        return number;
+    }
+
+    public boolean isAce() {
+        return number.isAce();
+    }
+
+    private boolean isSameShape(Shape shape) {
+        return this.shape == shape;
+    }
+
+    private boolean isSameNumber(Number number) {
+        return this.number == number;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Card card = (Card) o;
+        return shape == card.shape && number == card.number;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(shape, number);
+    }
+}

src/main/java/blackJack/domain/Card/CardFactory.java

@@ -0,0 +1,43 @@
+package blackJack.domain.Card;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class CardFactory {
+
+    public static final int INIT_CARD_SIZE = 2;
+
+    private final Queue<Card> deck;
+
+    public CardFactory() {
+        List<Card> cards = createCards();
+        Collections.shuffle(cards);
+        deck = new LinkedList<>(cards);
+    }
+
+    private List<Card> createCards() {
+        List<Card> cards = new ArrayList<>();
+        Arrays.stream(Shape.values())
+                .forEach(shape -> Arrays.stream(Number.values())
+                        .map(number -> Card.valueOf(shape, number))
+                        .forEach(cards::add));
+        return cards;
+    }
+
+    public Cards initCards() {
+        List<Card> cards = IntStream.range(0, INIT_CARD_SIZE)
+                .mapToObj(i -> drawOneCard())
+                .collect(Collectors.toList());
+
+        return new Cards(cards);
+    }
+
+    public Card drawOneCard() {
+        return deck.poll();
+    }
+
+    public int size() {
+        return deck.size();
+    }
+}

src/main/java/blackJack/domain/Card/Cards.java

@@ -0,0 +1,72 @@
+package blackJack.domain.Card;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import static blackJack.domain.Card.CardFactory.INIT_CARD_SIZE;
+
+public class Cards {
+    private static final int BUST_LINE = 21;
+    private static final int EXTRA_SCORE = 10;
+
+    private final Set<Card> cards;
+
+    public Cards(List<Card> deck) {
+        this(new HashSet<>(deck));
+    }
+
+    private Cards(Set<Card> deck) {
+        this.cards = new HashSet<>(deck);
+    }
+
+    public Set<Card> getCards() {
+        return new HashSet<>(cards);
+    }
+
+    public boolean add(Card card) {
+        return cards.add(card);
+    }
+
+    public int getScore() {
+        int score = cards.stream().mapToInt(card -> card.getNumber().getValue()).sum();
+
+        return addAceScore(score);
+    }
+
+    private int addAceScore(int score) {
+        long countAce = cards.stream().filter(Card::isAce).count();
+
+        for (int i = 0; i < countAce; i++) {
+            score = calculateAceScore(score);
+        }
+        return score;
+    }
+
+    private int calculateAceScore(int score) {
+        if (score + EXTRA_SCORE <= BUST_LINE) {
+            score += EXTRA_SCORE;
+        }
+        return score;
+    }
+
+    public int size() {
+        return cards.size();
+    }
+
+    public boolean isBlackJack() {
+        return cards.size() == INIT_CARD_SIZE && getScore() == BUST_LINE;
+    }
+
+    public boolean isBust() {
+        return getScore() > BUST_LINE;
+    }
+
+    public boolean isGreaterThan(Cards cards) {
+        return this.getScore() > cards.getScore();
+    }
+
+    public boolean isSameScore(Cards cards) {
+        return !isBust() && this.getScore() == cards.getScore();
+    }
+}

src/main/java/blackJack/domain/Card/Number.java

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

src/main/java/blackJack/domain/Card/Shape.java

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

src/main/java/blackJack/domain/PlayerResult.java

@@ -0,0 +1,39 @@
+package blackJack.domain;
+
+import blackJack.domain.User.Dealer;
+import blackJack.domain.User.Player;
+
+public enum PlayerResult {
+    WIN("승"),
+    DRAW("무"),
+    LOSE("패");
+
+    private final String value;
+
+    PlayerResult(String value) {
+        this.value = value;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public static PlayerResult decision(Dealer dealer, Player player) {
+        if (isAllBlackJack(dealer, player) || dealer.isSameScore(player)) {
+            return PlayerResult.DRAW;
+        }
+        if (isLose(dealer, player)) {
+            return PlayerResult.WIN;
+        }
+        return PlayerResult.LOSE;
+    }
+
+    private static boolean isLose(Dealer dealer, Player player) {
+        return player.isBlackJack() || dealer.isBust() || (player.isGreaterScoreThan(dealer) && !player.isBust());
+    }
+
+    private static boolean isAllBlackJack(Dealer dealer, Player player) {
+        return dealer.isBlackJack() && player.isBlackJack();
+    }
+
+}