[1단계 - 블랙잭 게임 실행] 리비(이근희) 미션 제출합니다.

README.md

@@ -1,7 +1,44 @@
-# java-blackjack
+# ♠️ java-blackjack ♠️
 
-블랙잭 미션 저장소
+- 블랙잭 게임을 변형한 프로그램을 구현한다.
+- 블랙잭 게임은 딜러와 플레이어 중 카드의 합이 21 또는 21에 가장 가까운 숫자를 가지는 쪽이 이기는 게임이다.
+- 카드의 숫자 계산은 카드 숫자를 기본으로 하며, 예외로 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)
+- [x] 입력
+    - [x] 게임에 참여할 사람의 이름을 입력 받을 수 있다.
+    - [x] 한 장 더 받을지 여부를 입력 받을 수 있다.
+- [x] 입력 검증
+    - [x] 카드 추가 여부를 올바른 형태 (y/n)으로 입력했는지 검증할 수 있다.
+- [x] 도메인
+    - [x] 이름은 빈 문자열일 수 없다.
+    - [x] 게임 참가자의 핸드에 새로운 카드를 추가할 수 있다.
+    - [x] 이름이 중복되는 플레이어는 존재할 수 없다.
+    - [x] 플레이어가 없는 경우는 게임을 시작할 수 없다.
+    - [x] 게임 참가자는 딜러 제외 3명 이하여야 한다.
+    - [x] 카드합을 계산할 때 Ace 카드는 1 또는 11로 계산한다
+    - [x] 카드합을 계산할 떄 J,Q,K카드는 각각 10으로 계산한다.
+    - [x] 점수를 계산할 때 Ace 카드가 있는 경우 21을 넘지 않으면서 가장 가깝도록 유리하게 계산한다
+    - [x] 카드합 비교를 통해서 플레이어의 승패를 결정할 수 있다.
+    - [x] 카드합 비교를 통해서 딜러의 승패를 계산할 수 있다.
+    - [x] 딜러는 17점 미만이면 카드를 받아야 한다.
+    - [x] 딜러는 17점 이상이면 카드를 그만 받아야 한다.
+    - [x] 핸드에서 에이스가 몇개있는지 파악할 수 있다
+    - [x] 핸드의 합을 계산할 수 있다.
+    - [x] 저지는 핸드에서 21에 가장 가까운 합을 구할 수 있다.
+    - [x] 핸드의 최소합이 21을 초과하면 플레이어는 버스트한다.
+    - [x] 핸드의 최소합이 21 이하면 플레이어는 카드를 뽑을지 여부를 선택할 수 있다.
+    - [x] 핸드에 카드를 추가할 수 있다.
+    - [x] 카드덱에서 카드를 지정한 개수만큼 건네줄 수 있다.
+    - [x] 카드덱에서 카드를 한 장 뽑아서 건네줄 수 있다.
+    - [x] 카드덱에서 보유한 카드 개수보다 많이 뽑으면 예외가 발생한다.
+    - [x] 참여자의 핸드에 초기 카드를 분배할 수 있다.
+- [x] 출력
+    - [x] 각 참여자의 카드 정보를 출력할 수 있다.
+    - [x] 각 참여자의 카드 합을 출력할 수 있다.
+    - [x] 최종 승패를 출력할 수 있다.

src/main/java/blackjack/Application.java

@@ -0,0 +1,17 @@
+package blackjack;
+
+import blackjack.view.InputView;
+import blackjack.view.MessageResolver;
+import blackjack.view.OutputView;
+
+public class Application {
+
+    public static void main(String[] args) {
+
+        InputView inputView = new InputView();
+        OutputView outputView = new OutputView(new MessageResolver());
+
+        BlackJackGame blackJackGame = new BlackJackGame(inputView, outputView);
+        blackJackGame.run();
+    }
+}

src/main/java/blackjack/BlackJackGame.java

@@ -0,0 +1,101 @@
+package blackjack;
+
+import static blackjack.domain.DrawDecision.YES;
+
+import blackjack.domain.DrawDecision;
+import blackjack.domain.card.Card;
+import blackjack.domain.card.CardDeck;
+import blackjack.domain.player.Dealer;
+import blackjack.domain.player.Hand;
+import blackjack.domain.player.Participant;
+import blackjack.domain.player.Player;
+import blackjack.domain.player.PlayerName;
+import blackjack.domain.player.Players;
+import blackjack.domain.rule.Judge;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+import java.util.List;
+
+public class BlackJackGame {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public BlackJackGame(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void run() {
+        CardDeck cardDeck = CardDeck.createShuffledDeck();
+        Players players = initPlayers(cardDeck);
+        Dealer dealer = new Dealer(Hand.createHandFrom(cardDeck));
+        printPlayersInformation(players, dealer);
+
+        completePlayersHand(players, cardDeck);
+        completeDealerHand(dealer, cardDeck);
+        outputView.printDealerPopCount(Dealer.HIT_THRESHOLD, dealer.countPop());
+
+        printParticipantScore(dealer);
+        printPlayersScore(players);
+        printDealerGameResult(dealer, players);
+        printPlayersGameResult(players, dealer);
+    }
+
+    private Players initPlayers(CardDeck cardDeck) {
+        InputMapper inputMapper = new InputMapper();
+        List<PlayerName> playerNames = inputMapper.mapToPlayers(inputView.readNames());
+
+        return new Players(playerNames.stream()
+                .map(playerName -> new Player(playerName, Hand.createHandFrom(cardDeck)))
+                .toList());
+    }
+
+    private void printPlayersInformation(Players players, Dealer dealer) {
+        outputView.printHandOutEvent(players, 2);
+        outputView.printDealerInitialHand(dealer);
+        players.getPlayers().forEach(outputView::printPlayerHand);
+    }
+
+    private void completePlayersHand(Players players, CardDeck cardDeck) {
+        players.getPlayers().forEach(player -> completePlayerHand(player, cardDeck));
+    }
+
+    private void completePlayerHand(Player participant, CardDeck cardDeck) {
+        while (participant.canHit() && readHitDecision(participant) == YES) {
+            participant.appendCard(cardDeck.popCard());
+            outputView.printPlayerHand(participant);
+        }
+    }
+
+    private DrawDecision readHitDecision(Player participant) {
+        InputMapper inputMapper = new InputMapper();
+        return inputMapper.mapToDrawDecision(inputView.readDrawPlan(participant.getName()));
+    }
+
+    private void completeDealerHand(Dealer dealer, CardDeck cardDeck) {
+        while (dealer.canHit()) {
+            Card card = cardDeck.popCard();
+            dealer.appendCard(card);
+        }
+    }
+
+    private void printPlayersScore(Players players) {
+        players.getPlayers().forEach(this::printParticipantScore);
+    }
+
+    private void printParticipantScore(Participant participant) {
+        outputView.printParticipantScore(participant, participant.calculateHandScore());
+    }
+
+    private void printDealerGameResult(Dealer dealer, Players players) {
+        Judge judge = new Judge();
+        outputView.printDealerGameResult(judge.calculateDealerGameResult(dealer, players));
+    }
+
+    private void printPlayersGameResult(Players players, Dealer dealer) {
+        Judge judge = new Judge();
+        players.getPlayers()
+                .forEach(player -> outputView.printPlayerGameResult(player, judge.isPlayerWin(dealer, player)));
+    }
+}

src/main/java/blackjack/InputMapper.java

@@ -0,0 +1,22 @@
+package blackjack;
+
+import blackjack.domain.DrawDecision;
+import blackjack.domain.player.PlayerName;
+import java.util.Arrays;
+import java.util.List;
+
+public class InputMapper {
+
+    private static final String DELIMITER = ",";
+
+    public List<PlayerName> mapToPlayers(String target) {
+        String[] split = target.split(DELIMITER);
+        return Arrays.stream(split)
+                .map(PlayerName::new)
+                .toList();
+    }
+
+    public DrawDecision mapToDrawDecision(String target) {
+        return DrawDecision.from(target);
+    }
+}

src/main/java/blackjack/domain/DealerGameResult.java

@@ -0,0 +1,20 @@
+package blackjack.domain;
+
+public class DealerGameResult {
+
+    private final int winCount;
+    private final int loseCount;
+
+    public DealerGameResult(int winCount, int loseCount) {
+        this.winCount = winCount;
+        this.loseCount = loseCount;
+    }
+
+    public int getWinCount() {
+        return winCount;
+    }
+
+    public int getLoseCount() {
+        return loseCount;
+    }
+}

src/main/java/blackjack/domain/DrawDecision.java

@@ -0,0 +1,22 @@
+package blackjack.domain;
+
+import java.util.Arrays;
+
+public enum DrawDecision {
+
+    YES("y"),
+    NO("n");
+
+    private final String code;
+
+    DrawDecision(String code) {
+        this.code = code;
+    }
+
+    public static DrawDecision from(String code) {
+        return Arrays.stream(values())
+                .filter(drawDecision -> drawDecision.code.equals(code))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("[ERROR] " + YES.code + "또는 " + NO.code + "로 입력해주세요"));
+    }
+}

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

@@ -0,0 +1,43 @@
+package blackjack.domain.card;
+
+import java.util.Objects;
+
+public class Card {
+
+    private final CardShape cardShape;
+    private final CardNumber cardNumber;
+
+    public Card(CardShape cardShape, CardNumber cardNumber) {
+        this.cardShape = cardShape;
+        this.cardNumber = cardNumber;
+    }
+
+    public boolean isAce() {
+        return cardNumber.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 cardShape == card.cardShape && cardNumber == card.cardNumber;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(cardShape, cardNumber);
+    }
+
+    public CardNumber getCardNumber() {
+        return cardNumber;
+    }
+
+    public CardShape getCardShape() {
+        return cardShape;
+    }
+}

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

@@ -0,0 +1,38 @@
+package blackjack.domain.card;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class CardDeck {
+
+    private final List<Card> cards;
+
+    CardDeck(List<Card> cards) {
+        this.cards = cards;
+    }
+
+    public static CardDeck createShuffledDeck() {
+        List<Card> cards = Arrays.stream(CardShape.values())
+                .flatMap(shape -> Arrays.stream(CardNumber.values())
+                        .map(number -> new Card(shape, number)))
+                .collect(Collectors.toList());
+        Collections.shuffle(cards);
+        return new CardDeck(cards);
+    }
+
+    public Card popCard() {
+        if (cards.isEmpty()) {
+            throw new IllegalArgumentException("[ERROR] 남아있는 카드가 부족하여 카드를 뽑을 수 없습니다");
+        }
+        return cards.remove(cards.size() - 1);
+    }
+
+    public List<Card> popCards(int count) {
+        return IntStream.range(0, count)
+                .mapToObj(i -> popCard())
+                .collect(Collectors.toList());
+    }
+}

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

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

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

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

src/main/java/blackjack/domain/player/Dealer.java

@@ -0,0 +1,16 @@
+package blackjack.domain.player;
+
+public class Dealer extends Participant {
+
+    private static final String DEALER_NAME = "딜러";
+    public static final int HIT_THRESHOLD = 16;
+
+    public Dealer(Hand hand) {
+        super(new PlayerName(DEALER_NAME), hand);
+    }
+
+    @Override
+    public boolean canHit() {
+        return hand.calculateCardSummation() <= HIT_THRESHOLD;
+    }
+}