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

docs/READMD.md

@@ -0,0 +1,26 @@
+## 도메인
+
+### 카드 값
+
+- [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] 카드를 한장씩 준다.

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.area.CardArea;
+import domain.deck.CardDeck;
+import domain.player.dealer.Dealer;
+import domain.player.dealer.DealerResult;
+import domain.player.Name;
+import domain.player.participant.Participant;
+import domain.player.participant.ParticipantResult;
+import domain.player.participant.State;
+import view.InputView;
+import view.OutputView;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static java.util.stream.Collectors.counting;
+
+public class BlackJackController {
+
+    public void run() {
+
+        final CardDeck cardDeck = CardDeck.shuffledFullCardDeck();
+
+        final List<Participant> participants = dealParticipantsCards(cardDeck);
+        final Dealer dealer = dealDealerCards(cardDeck);
+
+        printStateAfterDealtCard(participants, dealer);
+        hittingPlayer(cardDeck, participants, dealer);
+        printStateAfterHittedCard(participants, dealer);
+
+        final Map<Participant, ParticipantResult> playersResult = determineWinner(participants, dealer);
+        final Map<DealerResult, Long> scoreBoard = countDealerResult(playersResult);
+
+        printPlayerScoreBoard(participants, playersResult, scoreBoard);
+    }
+
+    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 printStateAfterHittedCard(final List<Participant> participants, final Dealer dealer) {
+        OutputView.showPlayerStateResult(dealer);
+        OutputView.showParticipantsStateResult(participants);
+    }
+
+    private void hittingPlayer(final CardDeck cardDeck, final List<Participant> participants, final Dealer dealer) {
+        hitForParticipants(cardDeck, participants);
+        hitForDealer(cardDeck, dealer);
+    }
+
+    private static void printStateAfterDealtCard(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 static Map<Participant, ParticipantResult> determineWinner(final List<Participant> participants,
+                                                                       final Dealer dealer) {
+        return participants.stream()
+                           .collect(Collectors.toMap(
+                                   Function.identity(),
+                                   participant -> ParticipantResult.matchBetween(participant, dealer))
+                           );
+    }
+
+    private void hitForDealer(final CardDeck cardDeck, final Dealer dealer) {
+        while (dealer.canHit()) {
+            OutputView.dealerOneMoreCard();
+            dealer.hit(cardDeck.draw());
+        }
+    }
+
+    private void hitForParticipants(final CardDeck cardDeck, final List<Participant> participants) {
+        participants.forEach(participant -> hitForParticipant(cardDeck, participant));
+    }
+
+    private void hitForParticipant(final CardDeck cardDeck, final Participant participant) {
+        while (participant.canHit()) {
+            participant.changeState(inputHitOrStay(participant));
+            determineHitForParticipant(cardDeck, participant);
+        }
+    }
+
+    private void determineHitForParticipant(final CardDeck cardDeck, final Participant participant) {
+        if (participant.wantHit()) {
+            participant.hit(cardDeck.draw());
+        }
+        OutputView.showStateOf(participant);
+    }
+
+    private State inputHitOrStay(final Participant participant) {
+        if (InputView.readMoreCard(participant).equals("y")) {
+            return State.HIT;
+        }
+        return State.STAY;
+    }
+
+    private Dealer dealDealerCards(final CardDeck cardDeck) {
+        return new Dealer(new CardArea(cardDeck.draw(), cardDeck.draw()));
+    }
+
+    private List<Participant> dealParticipantsCards(final CardDeck cardDeck) {
+        return InputView.readParticipantsName()
+                        .stream()
+                        .map(Name::new)
+                        .map(name -> new Participant(name, new CardArea(cardDeck.draw(), cardDeck.draw())))
+                        .collect(Collectors.toList());
+    }
+}

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

@@ -0,0 +1,60 @@
+package domain.area;
+
+import domain.card.Card;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CardArea {
+
+    private final List<Card> cards = new ArrayList<>();
+
+    public CardArea(final Card firstCard, final Card secondCard) {
+        cards.addAll(List.of(firstCard, secondCard));
+    }
+
+    public List<Card> cards() {
+        return new ArrayList<>(cards);
+    }
+
+    public void addCard(final Card card) {
+        cards.add(card);
+    }
+
+    public int calculate() {
+        int aceCount = countAceCard();
+        int totalValue = sumTotalCardValue();
+
+        while (aceCount > 0) {
+            if (totalValue <= 11) {
+                totalValue += 10;
+            }
+            aceCount--;
+        }
+        return totalValue;
+    }
+
+    private int sumTotalCardValue() {
+        return cards.stream()
+                    .mapToInt(card -> card.cardValue().value())
+                    .sum();
+    }
+
+    private int countAceCard() {
+        return (int) cards.stream()
+                          .filter(card -> card.cardValue().isAce())
+                          .count();
+    }
+
+    public boolean canMoreCard() {
+        return calculate() < 21;
+    }
+
+    public boolean isBurst() {
+        return calculate() > 21;
+    }
+
+    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;
+    }
+}

src/main/java/domain/deck/CardDeck.java

@@ -0,0 +1,35 @@
+package domain.deck;
+
+import domain.card.Card;
+import domain.card.CardShape;
+import domain.card.CardValue;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Stack;
+import java.util.stream.Collectors;
+
+public class CardDeck {
+
+    private final Stack<Card> cards;
+
+    private CardDeck(final Stack<Card> cards) {
+        this.cards = cards;
+    }
+
+    public static CardDeck shuffledFullCardDeck() {
+
+        Stack<Card> cards = Arrays.stream(CardShape.values())
+                                  .flatMap(cardShape -> Arrays.stream(CardValue.values())
+                                                              .map(cardValue -> new Card(cardShape, cardValue)))
+                                  .collect(Collectors.toCollection(Stack::new));
+
+        Collections.shuffle(cards);
+
+        return new CardDeck(cards);
+    }
+
+    public Card draw() {
+        return cards.pop();
+    }
+}

src/main/java/domain/player/Name.java

@@ -0,0 +1,21 @@
+package domain.player;
+
+public class Name {
+
+    private final String value;
+
+    public Name(final String name) {
+        validateEmpty(name);
+        this.value = name;
+    }
+
+    private void validateEmpty(final String name) {
+        if (name == null || name.isBlank()) {
+            throw new IllegalArgumentException("이름은 빈칸일 수 없습니다.");
+        }
+    }
+
+    public String value() {
+        return value;
+    }
+}

src/main/java/domain/player/Player.java

@@ -0,0 +1,37 @@
+package domain.player;
+
+import domain.area.CardArea;
+import domain.card.Card;
+
+public abstract class Player {
+
+    protected final Name name;
+    protected final CardArea cardArea;
+
+    protected Player(final Name name, final CardArea cardArea) {
+        this.name = name;
+        this.cardArea = cardArea;
+    }
+
+    public Name name() {
+        return name;
+    }
+
+    public CardArea cardArea() {
+        return cardArea;
+    }
+
+    public boolean isBurst() {
+        return cardArea.isBurst();
+    }
+
+    public void hit(final Card card) {
+        cardArea.addCard(card);
+    }
+
+    public abstract boolean canHit();
+
+    public int score() {
+        return cardArea.calculate();
+    }
+}