[2단계 - 블랙잭 베팅] 우르(김현우) 미션 제출합니다.

src/main/java/controller/BlackJackController.java

@@ -5,9 +5,8 @@
 import domain.player.Name;
 import domain.player.Player;
 import domain.player.dealer.Dealer;
-import domain.player.dealer.DealerResult;
+import domain.player.participant.Money;
 import domain.player.participant.Participant;
-import domain.player.participant.ParticipantResult;
 import view.InputView;
 import view.OutputView;
 
@@ -16,8 +15,6 @@
 import java.util.Map;
 import java.util.stream.Collectors;
 
-import static java.util.stream.Collectors.counting;
-
 public class BlackJackController {
 
     public void run() {
@@ -29,96 +26,103 @@ public void run() {
         final Dealer dealer = createDealer();
         final List<Player> players = createPlayers(participants, dealer);
 
-        deal(cardTable, players);
-
-        printStateAfterDeal(participants, dealer);
-        hittingPlayer(cardTable, participants, dealer);
-        printStateAfterHit(participants, dealer);
+        firstDeal(cardTable, players);
+        printStateAfterFirstDeal(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);
+        finalDeal(cardTable, participants, dealer);
+        printStateAfterFinalDeal(participants, dealer);
 
-        return players;
+        printPlayersMoneyBoard(cardTable, participants, dealer);
     }
 
-    private static void deal(final CardTable cardTable, final List<Player> players) {
+    private void firstDeal(final CardTable cardTable, final List<Player> players) {
         dealCard(cardTable, players);
         dealCard(cardTable, players);
     }
 
-    private static void dealCard(final CardTable cardTable, final List<Player> players) {
+    private void dealCard(final CardTable cardTable, final List<Player> players) {
         players.forEach(cardTable::dealCardTo);
     }
 
-    private static Dealer createDealer() {
-        return new Dealer();
+    private void printStateAfterFirstDeal(final List<Participant> participants, final Dealer dealer) {
+        OutputView.showDealtCardTo(participants);
+        OutputView.showStateOf(dealer);
+        OutputView.showStateOf(participants);
     }
 
-    private static List<Participant> createParticipants() {
-        return InputView.readParticipantsName()
-                        .stream()
-                        .map(Name::new)
-                        .map(Participant::new)
-                        .collect(Collectors.toList());
+    private void finalDeal(final CardTable cardTable, final List<Participant> participants, final Dealer dealer) {
+        hitForParticipants(cardTable, participants);
+        hitForDealer(cardTable, dealer);
     }
 
-    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 void hitForParticipants(final CardTable cardTable, final List<Participant> participants) {
+        participants.stream()
+                    .filter(Participant::isNotBlackjack)
+                    .forEach(participant -> hitForParticipant(cardTable, participant));
+
     }
 
-    private static void printStateAfterHit(final List<Participant> participants, final Dealer dealer) {
+    private void hitForParticipant(final CardTable cardTable, final Participant participant) {
+        while (participant.canHit() && selectHitOrStand(participant)) {
+            cardTable.dealCardTo(participant);
+            OutputView.showStateOf(participant);
+        }
+    }
+
+    private void hitForDealer(final CardTable cardTable, final Dealer dealer) {
+        do {
+            OutputView.dealerOneMoreCard();
+            cardTable.dealCardTo(dealer);
+        } while (dealer.canHit());
+    }
+
+    private void printStateAfterFinalDeal(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 void printPlayersMoneyBoard(final CardTable cardTable, final List<Participant> participants,
+                                        final Dealer dealer) {
+        printParticipantsMoneyBoard(cardTable, participants, dealer);
+        printDealerMoneyBoard(cardTable, participants, dealer);
     }
 
-    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 printParticipantsMoneyBoard(final CardTable cardTable, final List<Participant> participants,
+                                             final Dealer dealer) {
+        final Map<Participant, Money> participantsResult = cardTable.determineParticipantsBettingMoney(participants,
+                                                                                                       dealer);
+        OutputView.showBettingMoneyBoard(participantsResult);
     }
 
-    private void hittingPlayer(final CardTable cardTable, final List<Participant> participants, final Dealer dealer) {
-        hitForParticipants(cardTable, participants);
-        hitForDealer(cardTable, dealer);
+    private void printDealerMoneyBoard(final CardTable cardTable, final List<Participant> participants,
+                                       final Dealer dealer) {
+        final Money money = cardTable.determineDealerMoney(participants, dealer);
+        OutputView.showDealerMoneyBoard(money);
     }
 
-    private void hitForDealer(final CardTable cardTable, final Dealer dealer) {
-        do {
-            OutputView.dealerOneMoreCard();
-        } while (cardTable.dealCardTo(dealer));
+    private List<Player> createPlayers(final List<Participant> participants, final Dealer dealer) {
+        List<Player> players = new ArrayList<>(participants);
+        players.add(dealer);
+
+        return players;
     }
 
-    private void hitForParticipants(final CardTable cardTable, final List<Participant> participants) {
-        participants.forEach(participant -> hitForParticipant(cardTable, participant));
+    private Dealer createDealer() {
+        return new Dealer();
     }
 
-    private void hitForParticipant(final CardTable cardTable, final Participant participant) {
-        while (inputHitOrStay(participant)) {
-            cardTable.dealCardTo(participant);
-            OutputView.showStateOf(participant);
-        }
+    private List<Participant> createParticipants() {
+        return InputView.readParticipantsName()
+                        .stream()
+                        .map(Name::new)
+                        .map(name -> {
+                            final int bettingMoney = InputView.readBettingMoney(name);
+                            return new Participant(name, Money.wons(bettingMoney));
+                        })
+                        .collect(Collectors.toList());
     }
 
-    private boolean inputHitOrStay(final Participant participant) {
-        return InputView.readMoreCard(participant).equals("y");
+    private boolean selectHitOrStand(final Participant participant) {
+        return InputView.readMoreCard(participant);
     }
 }

src/main/java/domain/Score.java

@@ -8,7 +8,7 @@ public class Score {
 
     private static final Score UPPER_LIMIT_SCORE = new Score(21);
 
-    private static final Score REMAIN_SCORE_ACE = new Score(10);
+    private static final Score SOFT_HAND_SCORE = new Score(10);
 
     private final int value;
 
@@ -36,11 +36,11 @@ public boolean isGreaterThan(final Score other) {
         return value > other.value;
     }
 
-    public Score plusTenIfNotBurst() {
-        final Score plusScore = this.plus(REMAIN_SCORE_ACE);
+    public Score plusSoftHand() {
+        final Score plusScore = this.plus(SOFT_HAND_SCORE);
 
         if (plusScore.isLessEqualThan(UPPER_LIMIT_SCORE)) {
-            return this.plus(REMAIN_SCORE_ACE);
+            return this.plus(SOFT_HAND_SCORE);
         }
 
         return this;
@@ -50,6 +50,14 @@ public Score plus(Score other) {
         return new Score(value + other.value);
     }
 
+    public boolean isSumTwentyOne() {
+        return this.equals(UPPER_LIMIT_SCORE);
+    }
+
+    public boolean isSame(final Score other) {
+        return this.equals(other);
+    }
+
     @Override
     public boolean equals(final Object o) {
         if (this == o) return true;

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

@@ -22,8 +22,12 @@ public CardValue cardValue() {
 
     @Override
     public boolean equals(final Object o) {
-        if (this == o) return true;
-        if (!(o instanceof Card)) return false;
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof Card)) {
+            return false;
+        }
         final Card card = (Card) o;
         return cardShape == card.cardShape && cardValue == card.cardValue;
     }

src/main/java/domain/cardtable/CardTable.java

@@ -3,8 +3,9 @@
 import domain.deck.CardDeck;
 import domain.player.Player;
 import domain.player.dealer.Dealer;
+import domain.player.participant.Money;
 import domain.player.participant.Participant;
-import domain.player.participant.ParticipantResult;
+import domain.player.participant.betresult.resultfinder.BetResultFinder;
 
 import java.util.List;
 import java.util.Map;
@@ -14,45 +15,41 @@
 public class CardTable {
 
     private final CardDeck cardDeck;
+    private final BetResultFinder betResultFinder;
 
     private CardTable(final CardDeck cardDeck) {
         this.cardDeck = cardDeck;
+        this.betResultFinder = new BetResultFinder();
     }
 
     public static CardTable readyToPlayBlackjack(final CardDeck cardDeck) {
         return new CardTable(cardDeck);
     }
 
-    public Map<Participant, ParticipantResult> determineWinner(final List<Participant> participants,
-                                                               final Dealer dealer) {
+    public Map<Participant, Money> determineParticipantsBettingMoney(final List<Participant> participants,
+                                                                     final Dealer dealer) {
+
         return participants.stream()
                            .collect(Collectors.toMap(
                                    Function.identity(),
-                                   participant -> matchBetween(participant, dealer))
-                           );
+                                   participant -> participant.determineBetMoney(
+                                           betResultFinder.findStateOf(participant, dealer))
+                           ));
     }
 
-    private ParticipantResult matchBetween(final Participant participant, final Dealer dealer) {
-        if (participant.isBust()) {
-            return ParticipantResult.LOSER;
-        }
-        if (dealer.isBust()) {
-            return ParticipantResult.WINNER;
-        }
-        if (participant.score().isGreaterThan(dealer.score())) {
-            return ParticipantResult.WINNER;
-        }
-        if (participant.score().equals(dealer.score())) {
-            return ParticipantResult.DRAWER;
-        }
-        return ParticipantResult.LOSER;
+    public Money determineDealerMoney(final List<Participant> participants, final Dealer dealer) {
+
+        final Map<Participant, Money> participantsResultMoney = determineParticipantsBettingMoney(participants, dealer);
+
+        return participantsResultMoney.values()
+                                      .stream()
+                                      .reduce(Money.MIN, Money::plus)
+                                      .lose();
     }
 
-    public boolean dealCardTo(Player player) {
+    public void dealCardTo(Player player) {
         if (player.canHit()) {
             player.hit(cardDeck.draw());
-            return true;
         }
-        return false;
     }
 }

src/main/java/domain/area/CardArea.java → src/main/java/domain/hand/Hand.java

@@ -1,12 +1,12 @@
-package domain.area;
+package domain.hand;
 
 import domain.Score;
 import domain.card.Card;
 
 import java.util.ArrayList;
 import java.util.List;
 
-public class CardArea {
+public class Hand {
 
     private final List<Card> cards = new ArrayList<>();
 
@@ -21,8 +21,8 @@ public void addCard(final Card card) {
     public Score calculate() {
         Score score = score();
 
-        if (hasAce()) {
-            score = score.plusTenIfNotBurst();
+        if (isSoftHand()) {
+            return score.plusSoftHand();
         }
 
         return score;
@@ -35,7 +35,7 @@ private Score score() {
 
     }
 
-    private boolean hasAce() {
+    private boolean isSoftHand() {
         return cards.stream()
                     .anyMatch(card -> card.cardValue().isAce());
     }
@@ -48,7 +48,15 @@ public boolean isBust() {
         return calculate().isBust();
     }
 
+    public boolean isBlackjack() {
+        return cards.size() == 2 && calculate().isSumTwentyOne();
+    }
+
     public Card firstCard() {
         return cards.get(0);
     }
+
+    public Card secondCard() {
+        return cards.get(1);
+    }
 }