[1단계 - 블랙잭 게임 실행] 우르(김현우) 미션 제출합니다.

README.md

@@ -5,3 +5,45 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+## 도메인
+
+### 카드 값
+
+- [x] `2~10`, `A`, `K`, `Q`, `J` 가 있다.
+- [x] `K`, `Q`, `J` 는 10으로 계산된다.
+
+### 카드
+
+- [x] `다이아`, `클로버`, `하트`, `스페이드` 카드가 있다.
+- [x] `카드 값`을 가진다.
+
+### 카드 영역
+- [x] 딜러 카드 영역과 참가자 카드 영역으로 나뉜다.
+- [x] 카드들을 가진다.
+- [x] 카드를 더 받을 수 있는 상태인지 확인한다.
+- [x] 카드를 더 받을 것인지 결정한다.
+- [x] 카드 현숫자를 계산한다.
+- [X] `A` 는 1 또는 11로 계산될 수 있다.
+- [x] 카드를 추가할 수 있다.
+- [x] 처음에 카드 2장을 받아 생성된다.
+
+### 카드 덱
+
+- [x] 전체 카드를 가진다.
+- [x] 카드를 한장씩 준다.
+
+## refactoring
+
+### 카드 테이블
+- [x] `카드 영역`을 생성해준다.
+- [x] `딜러`와 `참여자`의 승부 결과를 알려줄 수 있다.
+
+### 점수
+- [x] 21점을 초과하는지 확인한다.
+- [x] 21점 미만인지 확인한다.
+- [x] 점수끼리 대소비교를 할 수 있다.
+  - [x] 작거나 같다.
+  - [x] 크다.
+  - [x] 작다.
+

src/main/java/BlackJackApplication.java

@@ -0,0 +1,7 @@
+import controller.BlackJackController;
+
+public class BlackJackApplication {
+    public static void main(String[] args) {
+        new BlackJackController().run();
+    }
+}

src/main/java/controller/BlackJackController.java

@@ -0,0 +1,124 @@
+package controller;
+
+import domain.cardtable.CardTable;
+import domain.deck.CardDeck;
+import domain.player.Name;
+import domain.player.Player;
+import domain.player.dealer.Dealer;
+import domain.player.dealer.DealerResult;
+import domain.player.participant.Participant;
+import domain.player.participant.ParticipantResult;
+import view.InputView;
+import view.OutputView;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static java.util.stream.Collectors.counting;
+
+public class BlackJackController {
+
+    public void run() {
+
+        final CardDeck cardDeck = CardDeck.shuffledFullCardDeck();
+        final CardTable cardTable = CardTable.readyToPlayBlackjack(cardDeck);
+
+        final List<Participant> participants = createParticipants();
+        final Dealer dealer = createDealer();
+        final List<Player> players = createPlayers(participants, dealer);
+
+        deal(cardTable, players);
+
+        printStateAfterDeal(participants, dealer);
+        hittingPlayer(cardTable, participants, dealer);
+        printStateAfterHit(participants, dealer);
+
+        final Map<Participant, ParticipantResult> participantsResult = cardTable.determineWinner(participants, dealer);
+        final Map<DealerResult, Long> scoreBoard = countDealerResult(participantsResult);
+
+        printPlayerScoreBoard(participants, participantsResult, scoreBoard);
+    }
+
+    private static List<Player> createPlayers(final List<Participant> participants, final Dealer dealer) {
+        List<Player> players = new ArrayList<>(participants);
+        players.add(dealer);
+
+        return players;
+    }
+
+    private static void deal(final CardTable cardTable, final List<Player> players) {
+        dealCard(cardTable, players);
+        dealCard(cardTable, players);
+    }
+
+    private static void dealCard(final CardTable cardTable, final List<Player> players) {
+        players.forEach(cardTable::dealCardTo);
+    }
+
+    private static Dealer createDealer() {
+        return new Dealer();
+    }
+
+    private static List<Participant> createParticipants() {
+        return InputView.readParticipantsName()
+                        .stream()
+                        .map(Name::new)
+                        .map(Participant::new)
+                        .collect(Collectors.toList());
+    }
+
+    private static void printPlayerScoreBoard(final List<Participant> participants,
+                                              final Map<Participant, ParticipantResult> playersResult,
+                                              final Map<DealerResult, Long> scoreBoard) {
+        OutputView.showDealerScoreBoard(scoreBoard);
+        OutputView.showParticipantsScoreBoard(playersResult, participants);
+    }
+
+    private static void printStateAfterHit(final List<Participant> participants, final Dealer dealer) {
+        OutputView.showPlayerStateResult(dealer);
+        OutputView.showParticipantsStateResult(participants);
+    }
+
+    private static void printStateAfterDeal(final List<Participant> participants, final Dealer dealer) {
+        OutputView.showDealtCardTo(participants);
+        OutputView.showStateOf(dealer);
+        OutputView.showStateOf(participants);
+    }
+
+    private static Map<DealerResult, Long> countDealerResult(
+            final Map<Participant, ParticipantResult> playersResult) {
+        return playersResult.keySet()
+                            .stream()
+                            .collect(Collectors.groupingBy(participant -> playersResult.get(participant)
+                                                                                       .convertToDealerResult(),
+                                                           counting()));
+    }
+
+    private void hittingPlayer(final CardTable cardTable, final List<Participant> participants, final Dealer dealer) {
+        hitForParticipants(cardTable, participants);
+        hitForDealer(cardTable, dealer);
+    }
+
+    private void hitForDealer(final CardTable cardTable, final Dealer dealer) {
+        do {
+            OutputView.dealerOneMoreCard();
+        } while (cardTable.dealCardTo(dealer));
+    }
+
+    private void hitForParticipants(final CardTable cardTable, final List<Participant> participants) {
+        participants.forEach(participant -> hitForParticipant(cardTable, participant));
+    }
+
+    private void hitForParticipant(final CardTable cardTable, final Participant participant) {
+        while (inputHitOrStay(participant)) {
+            cardTable.dealCardTo(participant);
+            OutputView.showStateOf(participant);
+        }
+    }
+
+    private boolean inputHitOrStay(final Participant participant) {
+        return InputView.readMoreCard(participant).equals("y");
+    }
+}

src/main/java/domain/Score.java

@@ -0,0 +1,69 @@
+package domain;
+
+import java.util.Objects;
+
+public class Score {
+
+    public static final Score MIN = new Score(0);
+
+    private static final Score UPPER_LIMIT_SCORE = new Score(21);
+
+    private static final Score REMAIN_SCORE_ACE = new Score(10);
+
+    private final int value;
+
+    public Score(final int value) {
+        this.value = value;
+    }
+
+    public boolean isBust() {
+        return this.isGreaterThan(UPPER_LIMIT_SCORE);
+    }
+
+    public boolean canMoreCard() {
+        return this.isLessThan(UPPER_LIMIT_SCORE);
+    }
+
+    public boolean isLessThan(final Score other) {
+        return value < other.value;
+    }
+
+    public boolean isLessEqualThan(final Score other) {
+        return value <= other.value;
+    }
+
+    public boolean isGreaterThan(final Score other) {
+        return value > other.value;
+    }
+
+    public Score plusTenIfNotBurst() {
+        final Score plusScore = this.plus(REMAIN_SCORE_ACE);
+
+        if (plusScore.isLessEqualThan(UPPER_LIMIT_SCORE)) {
+            return this.plus(REMAIN_SCORE_ACE);
+        }
+
+        return this;
+    }
+
+    public Score plus(Score other) {
+        return new Score(value + other.value);
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        final Score score = (Score) o;
+        return value == score.value;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
+
+    public int value() {
+        return value;
+    }
+}

src/main/java/domain/area/CardArea.java

@@ -0,0 +1,54 @@
+package domain.area;
+
+import domain.Score;
+import domain.card.Card;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CardArea {
+
+    private final List<Card> cards = new ArrayList<>();
+
+    public List<Card> cards() {
+        return new ArrayList<>(cards);
+    }
+
+    public void addCard(final Card card) {
+        cards.add(card);
+    }
+
+    public Score calculate() {
+        Score score = score();
+
+        if (hasAce()) {
+            score = score.plusTenIfNotBurst();
+        }
+
+        return score;
+    }
+
+    private Score score() {
+        return cards.stream()
+                    .map(card -> new Score(card.cardValue().value()))
+                    .reduce(Score.MIN, (Score::plus));
+
+    }
+
+    private boolean hasAce() {
+        return cards.stream()
+                    .anyMatch(card -> card.cardValue().isAce());
+    }
+
+    public boolean canMoreCard() {
+        return calculate().canMoreCard();
+    }
+
+    public boolean isBust() {
+        return calculate().isBust();
+    }
+
+    public Card firstCard() {
+        return cards.get(0);
+    }
+}

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

@@ -0,0 +1,35 @@
+package domain.card;
+
+import java.util.Objects;
+
+public class Card {
+
+    private final CardShape cardShape;
+    private final CardValue cardValue;
+
+    public Card(final CardShape cardShape, final CardValue cardValue) {
+        this.cardShape = cardShape;
+        this.cardValue = cardValue;
+    }
+
+    public CardShape cardShape() {
+        return cardShape;
+    }
+
+    public CardValue cardValue() {
+        return this.cardValue;
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Card)) return false;
+        final Card card = (Card) o;
+        return cardShape == card.cardShape && cardValue == card.cardValue;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(cardShape, cardValue);
+    }
+}

src/main/java/domain/card/CardShape.java

@@ -0,0 +1,9 @@
+package domain.card;
+
+public enum CardShape {
+    DIAMOND,
+    CLOVER,
+    HEART,
+    SPADE,
+    ;
+}

src/main/java/domain/card/CardValue.java

@@ -0,0 +1,34 @@
+package domain.card;
+
+public enum CardValue {
+
+    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;
+
+    CardValue(final int value) {
+        this.value = value;
+    }
+
+    public int value() {
+        return value;
+    }
+
+    public boolean isAce() {
+        return this == ACE;
+    }
+}