[2단계 - 블랙잭(베팅)] 오찌(오지훈) 미션 제출합니다.

README.md

@@ -5,6 +5,8 @@
 - [x] 카드 덱 생성하기
 - [x] 플레이어 이름 입력 받기
     - [x] 쉼표로 분리
+- [ ] 플레이어 별로 베팅 금액 입력 받기
+    - [ ] 숫자가 아니면 예외 발생
 - [x] 딜러 및 플레이어 생성하기
     - [x] 딜러 및 플레이어들에게 카드를 각각 두 장씩 주기
     - [x] 딜러의 카드는 첫 장만 공개
@@ -24,7 +26,15 @@
     - [x] 플레이어의 숫자가 21을 넘기면 무조건 플레이어의 패배
     - [x] 플레이어의 숫자가 딜러보다 21에 가까우면 플레이어의 승리
     - [x] 플레이어의 숫자가 21을 넘기지 않고 딜러의 숫자가 21을 넘기면 플레이어의 승리
-    - [x] 최종 승패 결과를 출력
+    - [x] 같은 21이어도 블랙잭(2장)이 승리
+    - [x] ~~최종 승패 결과를 출력~~
+- [x] 베팅 계산
+    - [x] 일반적인 상황에 대한 계산
+        - [x] 이기면 베팅 금액 만큼 수익
+        - [x] 지면 베팅 금액 만큼 손실
+        - [x] 비기면 베팅 금액을 돌려받음
+    - [x] 블랙잭으로 이기면 1.5배의 수익
+    - [ ] 최종 수익을 출력
 
 ---
 
@@ -53,12 +63,18 @@
         - 카드를 생성하는 전략을 제공하는 인터페이스
         - BlackJackCardsGenerator
             - CardsGenerator의 구현체로 서로 다른 52장의 카드를 가진 덱을 생성한다.
-- Rule
-    - 게임의 규칙을 담고 있다.
-    - 카드의 총합을 계산한다.
-    - 버스트(총합이 21을 넘는 경우) 여부를 판단한다.
-- Result
+- State
+    - 플레이어가 가질 수 있는 상태(버스트, 블랙잭)
+    - 보유한 카드를 받아서 상태를 판정한다.
+- Outcome
+    - 게임의 승, 무, 패
+    - 플레이어를 기준으로 딜러와 비교해서 판단한다.
+- Betting
+    - 플레이어의 베팅 정보를 저장한다.
+    - 상태
+- GameResult
     - 플레이어와 딜러의 카드를 받는다.
     - 승패를 결정한다.
-    - Judgement
-        - 승, 무, 패 값을 가진 enum
+    - 승패를 바탕으로 수익률을 저장한다
+    - Outcome
+        - 승, 무, 패 값을 가진 enum

src/main/java/blackjack/BlackjackApplication.java

@@ -0,0 +1,9 @@
+package blackjack;
+
+public class BlackjackApplication {
+
+    public static void main(String[] args) {
+        BlackjackGame blackjackGame = new BlackjackGame();
+        blackjackGame.play();
+    }
+}

src/main/java/blackjack/BlackJackGame.java → src/main/java/blackjack/BlackjackGame.java

@@ -1,9 +1,10 @@
 package blackjack;
 
+import blackjack.domain.Betting;
 import blackjack.domain.GameResult;
-import blackjack.domain.Name;
 import blackjack.domain.card.CardDeck;
 import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Name;
 import blackjack.domain.participant.Player;
 import blackjack.dto.HitRequest;
 import blackjack.dto.ParticipantInitialResponse;
@@ -13,10 +14,10 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class BlackJackGame {
+public class BlackjackGame {
 
     public void play() {
-        CardDeck deck = new CardDeck();
+        CardDeck deck = CardDeck.createGameDeck();
         Dealer dealer = new Dealer(deck.drawDouble());
         List<Player> players = createPlayers(inputPlayerNames(), deck);
         proceed(deck, dealer, players);
@@ -36,10 +37,19 @@ private List<Name> inputPlayerNames() {
 
     private List<Player> createPlayers(List<Name> playerNames, CardDeck deck) {
         return playerNames.stream()
-                .map(name -> new Player(name, deck.drawDouble()))
+                .map(name -> new Player(name, deck.drawDouble(), inputBetting(name)))
                 .collect(Collectors.toUnmodifiableList());
     }
 
+    private Betting inputBetting(Name name) {
+        try {
+            return new Betting(InputView.inputBetMoney(name.getValue()));
+        } catch (IllegalArgumentException e) {
+            OutputView.printErrorMessage(e.getMessage());
+            return inputBetting(name);
+        }
+    }
+
     private void proceed(CardDeck deck, Dealer dealer, List<Player> players) {
         alertStart(dealer, players);
         proceedPlayers(players, deck);
@@ -70,15 +80,15 @@ private void proceedPlayer(Player player, CardDeck deck) {
 
     private HitRequest inputHitRequest(Player player) {
         try {
-            return HitRequest.find(InputView.inputHitRequest(player.getName()));
+            return InputView.inputHitRequest(player.getName());
         } catch (IllegalArgumentException e) {
             OutputView.printErrorMessage(e.getMessage());
             return inputHitRequest(player);
         }
     }
 
     private void showStopReason(Player player) {
-        if (player.isBlackJack()) {
+        if (player.isBlackjack()) {
             OutputView.printBlackJackMessage(player.getName());
             return;
         }
@@ -98,6 +108,6 @@ private void showResult(Dealer dealer, List<Player> players) {
         OutputView.printCardResultMessage();
         OutputView.printParticipantCards(new ParticipantResponse(dealer));
         players.forEach(player -> OutputView.printParticipantCards(new ParticipantResponse(player)));
-        OutputView.printWinResult(GameResult.of(dealer, players));
+        OutputView.printGameResult(GameResult.of(dealer, players));
     }
 }

src/main/java/blackjack/domain/Betting.java

@@ -0,0 +1,21 @@
+package blackjack.domain;
+
+public class Betting {
+
+    private final int betMoney;
+
+    public Betting(int betMoney) {
+        validate(betMoney);
+        this.betMoney = betMoney;
+    }
+
+    private void validate(int betMoney) {
+        if (betMoney <= 0) {
+            throw new IllegalArgumentException("[ERROR] 베팅 금액은 0원 이하일 수 없습니다.");
+        }
+    }
+
+    public int getValue() {
+        return betMoney;
+    }
+}

src/main/java/blackjack/domain/GameResult.java

@@ -2,47 +2,42 @@
 
 import blackjack.domain.participant.Dealer;
 import blackjack.domain.participant.Player;
-import java.util.Arrays;
 import java.util.Collections;
-import java.util.EnumMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
 public class GameResult {
 
-    private final Map<Outcome, Integer> dealerResult;
-    private final Map<String, Outcome> playersResult;
+    private final Map<String, Integer> earnings;
 
-    private GameResult(Map<Outcome, Integer> dealerResult, Map<String, Outcome> playersResult) {
-        this.dealerResult = Collections.unmodifiableMap(new EnumMap<>(dealerResult));
-        this.playersResult = Collections.unmodifiableMap(new LinkedHashMap<>(playersResult));
+    public GameResult(Map<String, Integer> earnings) {
+        this.earnings = Collections.unmodifiableMap(new LinkedHashMap<>(earnings));
     }
 
     public static GameResult of(Dealer dealer, List<Player> players) {
-        Map<Outcome, Integer> dealerResult = new EnumMap<>(Outcome.class);
-        Map<String, Outcome> playersResult = new LinkedHashMap<>();
+        Map<String, Integer> playersEarnings = new LinkedHashMap<>();
 
-        initDealerResult(dealerResult);
         for (Player player : players) {
             Outcome playerOutcome = Outcome.judge(player, dealer);
-            playersResult.put(player.getName(), playerOutcome);
-            dealerResult.merge(playerOutcome.getOpposite(), 1, Integer::sum);
+            int playerEarnings = calculateEarnings(player, playerOutcome);
+            int dealerEarnings = getDealerEarnings(playerEarnings);
+            playersEarnings.merge(dealer.getName(), dealerEarnings, Integer::sum);
+            playersEarnings.put(player.getName(), playerEarnings);
         }
 
-        return new GameResult(dealerResult, playersResult);
+        return new GameResult(playersEarnings);
     }
 
-    private static void initDealerResult(Map<Outcome, Integer> dealerResult) {
-        Arrays.stream(Outcome.values())
-                .forEach(value -> dealerResult.put(value, 0));
+    private static int getDealerEarnings(int playerEarnings) {
+        return playerEarnings * (-1);
     }
 
-    public Map<Outcome, Integer> getDealerResult() {
-        return dealerResult;
+    private static int calculateEarnings(Player player, Outcome outcome) {
+        return (int) (player.getBetting().getValue() * outcome.getEarningsRate());
     }
 
-    public Map<String, Outcome> getPlayersResult() {
-        return playersResult;
+    public Map<String, Integer> getEarnings() {
+        return earnings;
     }
 }

src/main/java/blackjack/domain/Outcome.java

@@ -4,50 +4,50 @@
 import blackjack.domain.participant.Player;
 
 public enum Outcome {
-    WIN("승"),
-    DRAW("무"),
-    LOSE("패");
+    WIN("승", 1),
+    DRAW("무", 0),
+    LOSE("패", -1),
+    WIN_BLACKJACK("승", 1.5);
 
     private final String name;
+    private final double earningsRate;
 
-    Outcome(String name) {
+    Outcome(String name, double earningsRate) {
         this.name = name;
+        this.earningsRate = earningsRate;
     }
 
     public static Outcome judge(Player player, Dealer dealer) {
-        if (player.isBust() || !player.isBlackJack() && dealer.isBlackJack()) {
+        if (player.isBlackjack() && !dealer.isBlackjack()) {
+            return WIN_BLACKJACK;
+        }
+        if (player.isBust() || !player.isBlackjack() && dealer.isBlackjack()) {
             return Outcome.LOSE;
         }
-        if (dealer.isBust() || player.isBlackJack() && !dealer.isBlackJack()) {
+        if (dealer.isBust() || player.isBlackjack() && !dealer.isBlackjack()) {
             return Outcome.WIN;
         }
-        if (player.isBlackJack() && dealer.isBlackJack()) {
+        if (player.isBlackjack() && dealer.isBlackjack()) {
             return Outcome.DRAW;
         }
         return judgeByScore(player.getScore(), dealer.getScore());
     }
 
-    private static Outcome judgeByScore(int score, int target) {
-        if (score > target) {
+    private static Outcome judgeByScore(Score score, Score target) {
+        if (score.compareTo(target) > 0) {
             return Outcome.WIN;
         }
-        if (score == target) {
+        if (score.equals(target)) {
             return Outcome.DRAW;
         }
         return Outcome.LOSE;
     }
 
-    public Outcome getOpposite() {
-        if (this == WIN) {
-            return LOSE;
-        }
-        if (this == LOSE) {
-            return WIN;
-        }
-        return DRAW;
-    }
-
     public String getName() {
         return name;
     }
+
+    public double getEarningsRate() {
+        return earningsRate;
+    }
 }

src/main/java/blackjack/domain/Score.java

@@ -1,6 +1,6 @@
 package blackjack.domain;
 
-public class Score {
+public class Score implements Comparable<Score> {
 
     private final int value;
 
@@ -12,6 +12,15 @@ public int getValue() {
         return value;
     }
 
+    public boolean isLessThan(int value) {
+        return this.value < value;
+    }
+
+    @Override
+    public int compareTo(Score target) {
+        return Integer.compare(value, target.value);
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) {

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

@@ -1,7 +1,14 @@
 package blackjack.domain.card;
 
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
 public class Card {
 
+    private static final List<Card> pool = createCardPool();
+
     private final Pattern pattern;
     private final Denomination denomination;
 
@@ -10,6 +17,30 @@ public Card(Pattern pattern, Denomination denomination) {
         this.denomination = denomination;
     }
 
+    public static Card of(Pattern pattern, Denomination denomination) {
+        return pool.stream()
+                .filter(card -> card.pattern == pattern && card.denomination == denomination)
+                .findAny()
+                .orElseThrow(() -> new IllegalArgumentException("[ERROR] 올바르지 않은 카드입니다."));
+    }
+
+    private static List<Card> createCardPool() {
+        return Arrays.stream(Pattern.values())
+                .map(Card::createCardsBy)
+                .flatMap(Collection::stream)
+                .collect(Collectors.toList());
+    }
+
+    private static List<Card> createCardsBy(Pattern pattern) {
+        return Arrays.stream(Denomination.values())
+                .map(denomination -> new Card(pattern, denomination))
+                .collect(Collectors.toList());
+    }
+
+    public static List<Card> getPool() {
+        return pool;
+    }
+
     public Pattern getPattern() {
         return pattern;
     }