레디 step1 미션 제출

docs/README.md

@@ -0,0 +1,63 @@
+# 블랙잭 규칙
+
+## 참여자
+
+**승**
+
+* (딜러 카드 합 < 참여자 카드 합) && 참여자가 버스트가 아닌 경우
+* (딜러 카드 합 == 참여자 카드 합) && (딜러 카드 수 > 참여자 카드 수) && 참여자가 버스트가 아닌 경우
+* 딜러가 버스트인 경우 && 참여자가 버스트가 아닌 경우
+
+**무**
+
+* (딜러 카드 합 == 참여자 카드 합) && (딜러 카드 수 == 참여자 카드 수) && 참여자가 버스트가 아닌 경우
+
+**패**
+
+* 참여자가 버스트인 경우
+* (딜러 카드 합 > 참여자 카드 합)
+
+<br>
+
+# 기능 요구 사항
+
+* [x] 참여자 이름 입력 받는다.
+    * [x] 양 끝 공백을 제거한다.
+    * [x] 참여자는 쉼표(,)로 구분한다.
+    * [x] null 이나 공백인 경우 예외가 발생한다.
+    * [x] 쉼표로 시작시 예외가 발생한다. ex) ,pobi,jason
+    * [x] 쉼표로 끝날시 예외가 발생한다. ex) pobi,jason,
+    * [x] 쉼표가 연속으로 올시 예외가 발생한다. ex) pobi,,jason
+    * [x] 참여자 이름이 중복시 예외가 발생한다.
+* [x] 총 참여자의 수는 2이상 8이하여야 한다.
+
+<br>
+
+* [x] 딜러가 카드 2장을 분배하다.
+    * [x] 카드는 총 6벌을 둔다. (52 * 6)
+* [x] 딜러의 카드를 출력한다. (1장)
+* [x] 참여자의 카드를 출력한다. (2장)
+
+<br>
+
+* [x] 참여자는 hit(y) / stay(n)를 선택한다.
+    * [x] y, n 가 아닐시 예외가 발생한다.
+* [x] 참여자가 hit을 하는 경우 현재 가지고 있는 카드를 출력한다.
+* [x] 참여자가 hit을 한 적 없이 stay를 하는 경우 현재 가지고 있는 카드를 출력한다.
+* [x] 카드 합이 블랙잭인 경우 블랙잭 메시지를 출력한다.
+* [x] 카드 합이 21 초과시 버스트 메시지를 출력한다.
+
+<br>
+
+* [x] 딜러의 카드의 합을 계산한다.
+* [x] 카드 내의 ACE 가 포함된 경우
+    * ACE: 11
+    * 11로 했을 때 카드의 합이 21을 초과한 경우 1로 계산
+* [x] 17 이상이 될때까지 카드를 받는다.
+
+<br>
+
+* [x] 모든 참여자의 카드의 합을 계산한다.
+* [x] 딜러의 승패무를 확인한다.
+* [x] 참여자의 승패무를 확인한다.
+* [x] 게임 결과를 출력한다.

src/main/java/application/Application.java

@@ -0,0 +1,16 @@
+package application;
+
+import controller.BlackJackController;
+import java.util.Scanner;
+import view.InputView;
+import view.OutputView;
+
+public class Application {
+    public static void main(String[] args) {
+        final Scanner scanner = new Scanner(System.in);
+        final InputView inputView = new InputView(scanner);
+        final OutputView outputView = new OutputView();
+        final BlackJackController blackJackController = new BlackJackController(inputView, outputView);
+        blackJackController.run();
+    }
+}

src/main/java/controller/BlackJackController.java

@@ -0,0 +1,98 @@
+package controller;
+
+import domain.Answer;
+import domain.CardDeck;
+import domain.Game;
+import domain.participant.Dealer;
+import domain.participant.Player;
+import domain.participant.Players;
+import dto.DealerHandsDto;
+import dto.ParticipantDto;
+import dto.ParticipantsDto;
+import view.InputView;
+import view.OutputView;
+
+public class BlackJackController {
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public BlackJackController(final InputView inputView, final OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void run() {
+        final Players players = Players.from(inputView.readNames());
+        final CardDeck cardDeck = CardDeck.generate();
+        final Dealer dealer = new Dealer(cardDeck);
+        final Game game = new Game(dealer, players);
+
+        initHands(players, dealer);
+        dealWithPlayers(players, dealer);
+
+        if (!players.isAllBust()) {
+            dealer.deal();
+            printDealerTurnMessage(dealer.countAddedHands());
+        }
+        printFinalResult(players, dealer, game);
+    }
+
+    private void printDealerTurnMessage(final int turn) {
+        for (int i = 0; i < turn; i++) {
+            outputView.printDealerTurnMessage();
+        }
+    }
+
+    private void dealWithPlayers(final Players players, final Dealer dealer) {
+        for (Player player : players.getPlayers()) {
+            deal(player, dealer);
+        }
+    }
+
+    private void initHands(final Players players, final Dealer dealer) {
+        dealer.initHands(players);
+        outputView.printStartDeal(DealerHandsDto.from(dealer), ParticipantsDto.of(players));
+    }
+
+    private void printFinalResult(final Players players, final Dealer dealer, final Game game) {
+        outputView.printHandsResult(ParticipantsDto.of(dealer, players));
+        outputView.printGameResult(game.getDealerResult(), game.getPlayersResult());
+    }
+
+    private void deal(final Player player, final Dealer dealer) {
+        boolean handsChanged = false;
+        boolean turnEnded = false;
+
+        while (!turnEnded) {
+            Answer answer = Answer.from(inputView.readAnswer(player.getName()));
+            dealer.deal(player, answer);
+
+            printHandsIfRequired(player, handsChanged, answer);
+
+            handsChanged = true;
+            turnEnded = isTurnEnded(player, answer);
+        }
+    }
+
+    private void printHandsIfRequired(final Player player, final boolean handsChanged, final Answer answer) {
+        if (shouldShowHands(handsChanged, answer)) {
+            outputView.printHands(ParticipantDto.from(player));
+        }
+    }
+
+    private boolean isTurnEnded(final Player player, final Answer answer) {
+        if (player.isBust()) {
+            outputView.printBust();
+            return true;
+        }
+        if (player.isBlackJack()) {
+            outputView.printBlackJack();
+            return true;
+        }
+        return Answer.STAY.equals(answer);
+    }
+
+    private boolean shouldShowHands(final boolean handsChanged, final Answer answer) {
+        return (Answer.STAY.equals(answer) && !handsChanged) || Answer.HIT.equals(answer);
+    }
+}

src/main/java/domain/Answer.java

@@ -0,0 +1,21 @@
+package domain;
+
+import java.util.Arrays;
+
+public enum Answer {
+    HIT("y"),
+    STAY("n");
+
+    private final String value;
+
+    Answer(final String value) {
+        this.value = value;
+    }
+
+    public static Answer from(final String value) {
+        return Arrays.stream(Answer.values())
+                .filter(answer -> answer.value.equals(value))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("[ERROR] 유효하지 않은 대답입니다."));
+    }
+}

src/main/java/domain/CardDeck.java

@@ -0,0 +1,53 @@
+package domain;
+
+import domain.card.Card;
+import domain.card.Rank;
+import domain.card.Shape;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.List;
+
+public class CardDeck {
+    private static final int DECK_SIZE = 6;
+
+    private final Deque<Card> cards;
+
+    public CardDeck(final Deque<Card> cards) {
+        this.cards = cards;
+    }
+
+    public static CardDeck generate() {
+        final List<Card> deck = new ArrayList<>();
+
+        for (int i = 0; i < DECK_SIZE; i++) {
+            deck.addAll(generateOneCardDeck());
+        }
+
+        Collections.shuffle(deck);
+        return new CardDeck(new ArrayDeque<>(deck));
+    }
+
+    public Card pop() {
+        return cards.pop();
+    }
+
+    public int size() {
+        return cards.size();
+    }
+
+    private static List<Card> generateOneCardDeck() {
+        return Arrays.stream(Shape.values())
+                .flatMap(shape -> matching(shape).stream())
+                .toList();
+    }
+
+    private static List<Card> matching(final Shape shape) {
+        return Arrays.stream(Rank.values())
+                .map(rank -> new Card(rank, shape))
+                .toList();
+    }
+
+}

src/main/java/domain/Game.java

@@ -0,0 +1,39 @@
+package domain;
+
+import domain.participant.Dealer;
+import domain.participant.Player;
+import domain.participant.Players;
+import java.util.EnumMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class Game {
+
+    private final Dealer dealer;
+    private final Players players;
+
+    public Game(final Dealer dealer, final Players players) {
+        this.dealer = dealer;
+        this.players = players;
+    }
+
+    public Map<Player, Result> getPlayersResult() {
+        final Map<Player, Result> playerResult = new LinkedHashMap<>();
+
+        for (Player player : players.getPlayers()) {
+            playerResult.put(player, player.calculateResult(dealer));
+        }
+        return playerResult;
+    }
+
+    public Map<Result, Integer> getDealerResult() {
+        Map<Result, Integer> dealerResult = new EnumMap<>(Result.class);
+
+        for (Result value : getPlayersResult().values()) {
+            Result reversed = value.reverse();
+            Integer orDefault = dealerResult.getOrDefault(reversed, 0);
+            dealerResult.put(reversed, orDefault + 1);
+        }
+        return dealerResult;
+    }
+}

src/main/java/domain/Hands.java

@@ -0,0 +1,96 @@
+package domain;
+
+import domain.card.Card;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+public class Hands {
+
+    private static final int BLACK_JACK = 21;
+    public static final int EXTRA_ACE_VALUE = 10;
+
+    private final List<Card> cards;
+
+    public Hands(final List<Card> cards) {
+        this.cards = new ArrayList<>(cards);
+    }
+
+    public static Hands createEmptyPacket() {
+        return new Hands(new ArrayList<>());
+    }
+
+    public int sum() {
+        int total = cards.stream()
+                .mapToInt(Card::getCardNumber)
+                .sum();
+
+        return calculateTotalByAce(total);
+    }
+
+    public void add(final Card card) {
+        cards.add(card);
+    }
+
+    public boolean isBust() {
+        return sum() > BLACK_JACK;
+    }
+
+    public boolean isBlackJack() {
+        return sum() == BLACK_JACK;
+    }
+
+    private boolean hasAce() {
+        return cards.stream()
+                .anyMatch(Card::isAce);
+    }
+
+    public int size() {
+        return cards.size();
+    }
+
+    public List<String> getCards() {
+        return cards.stream()
+                .map(Card::toString)
+                .toList();
+    }
+
+    public Result calculateResult(final Hands target) {
+        if (!this.isBust() && target.isBust()) {
+            return Result.WIN;
+        }
+        if (this.sum() == target.sum() && this.size() == target.size() && !this.isBust()) {
+            return Result.TIE;
+        }
+        if (this.sum() >= target.sum() && this.sum() <= BLACK_JACK) {
+            return Result.WIN;
+        }
+        return Result.LOSE;
+    }
+
+    private int calculateTotalByAce(final int total) {
+        if (hasAce() && total + EXTRA_ACE_VALUE <= BLACK_JACK) {
+            return total + EXTRA_ACE_VALUE;
+        }
+
+        return total;
+    }
+
+    @Override
+    public boolean equals(final Object target) {
+        if (this == target) {
+            return true;
+        }
+
+        if (!(target instanceof Hands hands)) {
+            return false;
+        }
+
+        return Objects.equals(cards, hands.cards);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(cards);
+    }
+}