[🚀 사이클2 - 미션 (블랙잭 베팅)] 아나키 미션 제출합니다.

README.md

@@ -26,6 +26,9 @@
 - [x] 정상적인 이름 앞뒤의 공백 제거
 - [x] `ㅁㅁ, ,ㅇㅇ` → 빈 문자열은 예외처리
 
+### 베팅 금액 입력 기능
+- [ ]  각 플레이어의 베팅 금액을 입력 받는다
+
 ### 각 플레이어, 딜러에게 카드를 랜덤으로 2장 배분하는 기능
 
 - [x] 딜러는 2번째 카드는 출력하지 않음
@@ -51,8 +54,19 @@
 
 ### 카드 점수 합 계산 기능
 
-- [x] rank 값만 추출하여 합산
-- [x] 총합 계산 로직 구현
+- [xx] rank 값만 추출하여 합산
+- [] 총합 계산 로직 구현
+
+
+### 플레이어 수익 계산 기능
+
+- [x]  Result.WIN : 베팅 금액만큼 수익(+)
+- [x]  Result.LOSE : 베팅 금액만큼 손실(-)
+- [x]  Result.TIE : 베팅 금액 - 베팅 금액(0)
+- [x]  [특수] 처음 2장의 합이 21일 때 : 베팅 금액 * 1.5만큼 수익(+)
+
+### 딜러 수익 계산 기능
+- [x] 플레이어의 수익에 따라 딜러 수익을 계산
 
 ### 결과 출력
 
@@ -62,5 +76,4 @@
 - [x] 플레이어 카드 점수 합 출력
 
 ### 승패 출력
-
 - [x] 계산된 합에 따라 승패 판별

src/main/java/controller/BlackjackController.java

@@ -6,6 +6,7 @@
 import domain.Players;
 import domain.Referee;
 import domain.Result;
+import domain.Results;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -24,21 +25,18 @@ public BlackjackController(InputView inputView, OutputView outputView) {
 
     public void run() {
         List<String> names = inputView.inputPlayers();
-        Players players = new Players(names);
-        Dealer dealer = new Dealer("딜러");
+        List<Integer> betAmounts = inputView.inputBetAmount(names);
+        Players players = new Players(names,betAmounts);
+        Dealer dealer = new Dealer();
         Deck deck = new Deck();
         dealInitialCards(dealer, players, deck);
         dealInitialCards(dealer, players, deck);
         printInitialState(dealer, players, names);
         playAllPlayerTurns(players, deck);
         playDealerTurn(dealer, deck);
         printFinalState(dealer, players);
-    }
-
-    private void playAllPlayerTurns(Players players, Deck deck) {
-        for (Player player : players.getGamePlayers()) {
-            playPlayerTurn(player, deck);
-        }
+        printResult(dealer, players);
+        printProfit(dealer, players);
     }
 
     private void dealInitialCards(Dealer dealer, Players players, Deck deck) {
@@ -57,15 +55,16 @@ private void printInitialState(Dealer dealer, Players players, List<String> name
         System.out.println();
     }
 
+    private void playAllPlayerTurns(Players players, Deck deck) {
+        for (Player player : players.getGamePlayers()) {
+            playPlayerTurn(player, deck);
+        }
+    }
+
     private void playPlayerTurn(Player player, Deck deck) {
-        boolean cardShown = false;
         while (player.canHit() && inputView.askHit(player.getName())) {
             player.addCard(deck.draw());
             outputView.printPlayerCards(player);
-            cardShown = true;
-        }
-        if (!cardShown) {
-            outputView.printPlayerCards(player);
         }
     }
 
@@ -82,11 +81,27 @@ private void printFinalState(Dealer dealer, Players players) {
         for (Player player : players.getGamePlayers()) {
             outputView.printFinalCards(player);
         }
+    }
+
+    private void printResult(Dealer dealer, Players players) {
         Referee referee = new Referee();
-        Map<Player, Result> results = new LinkedHashMap<>();
+        Results results = new Results();
         for (Player player : players.getGamePlayers()) {
-            results.put(player, referee.judge(player.getScore(), dealer.getScore()));
+            results.add(player, referee.judge(player.getScore(), dealer.getScore()));
         }
         outputView.printFinalResult(dealer, results);
     }
+
+    private void printProfit(Dealer dealer, Players players) {
+        Referee referee = new Referee();
+        Map<Player, Integer> profit = new LinkedHashMap<>();
+        double dealerProfit = 0;
+        for (Player player : players.getGamePlayers()) {
+            Result result = referee.judge(player.getScore(), dealer.getScore());
+            int playerProfit = (int) referee.calculateProfit(result, player.getBetAmount());
+            dealerProfit -= playerProfit;
+            profit.put(player, playerProfit);
+        }
+        outputView.printFinalProfit(dealer, dealerProfit, profit);
+    }
 }

src/main/java/domain/Dealer.java

@@ -2,9 +2,10 @@
 
 public class Dealer extends Participant {
     private static final int HIT_THRESHOLD = 16;
+    private static final String DEALER_NAME = "딜러";
 
-    public Dealer(String name) {
-        super(name);
+    public Dealer() {
+        super(DEALER_NAME);
     }
 
     @Override

src/main/java/domain/Player.java

@@ -2,13 +2,19 @@
 
 public class Player extends Participant {
     private static final int BUST_THRESHOLD = 21;
+    private final int betAmount;
 
-    public Player(String name) {
+    public Player(String name, int betAmount) {
         super(name);
+        this.betAmount = betAmount;
     }
 
     @Override
     public boolean canHit() {
         return getScore() <= BUST_THRESHOLD;
     }
+
+    public int getBetAmount() {
+        return betAmount;
+    }
 }

src/main/java/domain/Players.java

@@ -7,11 +7,11 @@
 public class Players {
     private final List<Player> playerList;
 
-    public Players(List<String> names) {
+    public Players(List<String> names,List<Integer> betAmounts) {
         validateDuplicate(names);
         playerList = new ArrayList<>();
         for (String name : names) {
-            playerList.add(new Player(name));
+            playerList.add(new Player(name, betAmounts.get(names.indexOf(name))));
         }
     }
 

src/main/java/domain/Referee.java

@@ -3,6 +3,10 @@
 public class Referee {
     private static final int BUST_THRESHOLD = 21;
 
+    public boolean isBlackJack(int playerScore) {
+        return playerScore == BUST_THRESHOLD;
+    }
+
     public Result judge(int playerScore, int dealerScore) {
         if (playerScore > BUST_THRESHOLD) {
             return Result.LOSE;
@@ -18,4 +22,9 @@ public Result judge(int playerScore, int dealerScore) {
         }
         return Result.LOSE;
     }
+
+    public double calculateProfit(Result result, int betAmount) {
+        return result.getProfitRate() * betAmount;
+    }
+
 }

src/main/java/domain/Result.java

@@ -1,5 +1,18 @@
 package domain;
 
 public enum Result {
-    WIN, LOSE, TIE
+    BLACKJACK(1.5),
+    WIN(1),
+    LOSE(-1),
+    TIE(0);
+
+    private final double profitRate;
+
+    Result(double profitRate) {
+        this.profitRate = profitRate;
+    }
+
+    public double getProfitRate() {
+        return profitRate;
+    }
 }

src/main/java/domain/Results.java

@@ -0,0 +1,16 @@
+package domain;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Results {
+    private final Map<Player, Result> results = new HashMap<>();
+
+    public void add(Player player, Result result) {
+        results.put(player, result);
+    }
+
+    public Result findByPlayer(Player player) {
+        return results.get(player);
+    }
+}

src/main/java/view/InputView.java

@@ -1,5 +1,6 @@
 package view;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Scanner;
@@ -16,6 +17,17 @@ public List<String> inputPlayers() {
         return playerName;
     }
 
+    public List<Integer> inputBetAmount(List<String> names) {
+        List<Integer> betAmounts = new ArrayList<>();
+        for (String name : names) {
+            System.out.println(name + "의 배팅 금액은?");
+            int rawBetAmount = sc.nextInt();
+            sc.nextLine();
+            betAmounts.add(rawBetAmount);
+        }
+        return betAmounts;
+    }
+
     public boolean askHit(String playerName) {
         System.out.println(playerName + "는 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)");
         return sc.nextLine().equals("y");

src/main/java/view/OutputView.java

@@ -1,6 +1,7 @@
 package view;
 
 import domain.Card;
+import domain.Dealer;
 import domain.Participant;
 import domain.Player;
 import domain.Rank;
@@ -59,12 +60,34 @@ public void printFinalResult(Participant dealer, Map<Player, Result> results) {
         printPlayerResults(results);
     }
 
+    private void printPlayerResults(Map<Player, Result> results) {
+        for (Map.Entry<Player, Result> entry : results.entrySet()) {
+            System.out.println(entry.getKey().getName() + ": " + RESULT_NAME.get(entry.getValue()));
+        }
+    }
+
     private void printDealerResult(Participant dealer, Map<Player, Result> results) {
         int dealerWin = countResult(results, Result.LOSE);
         int dealerLose = countResult(results, Result.WIN);
         System.out.println(dealer.getName() + ": " + dealerWin + "승 " + dealerLose + "패");
     }
 
+    public void printFinalProfit(Dealer dealer, double dealerProfit, Map<Player, Integer> results) {
+        System.out.println("\n## 최종 수익");
+        printDealerProfit(dealer, (int) dealerProfit);
+        printPlayerProfit(results);
+    }
+
+    private void printPlayerProfit(Map<Player, Integer> results) {
+        for (Map.Entry<Player, Integer> entry : results.entrySet()) {
+            System.out.println(entry.getKey().getName() + ": " + entry.getValue());
+        }
+    }
+
+    private void printDealerProfit(Dealer dealer, int profit) {
+        System.out.println(dealer.getName() + ": " + profit);
+    }
+
     private int countResult(Map<Player, Result> results, Result target) {
         int count = 0;
         for (Result result : results.values()) {
@@ -75,12 +98,6 @@ private int countResult(Map<Player, Result> results, Result target) {
         return count;
     }
 
-    private void printPlayerResults(Map<Player, Result> results) {
-        for (Map.Entry<Player, Result> entry : results.entrySet()) {
-            System.out.println(entry.getKey().getName() + ": " + RESULT_NAME.get(entry.getValue()));
-        }
-    }
-
     private String formatCards(List<Card> cards) {
         List<String> cardNames = new ArrayList<>();
         for (Card card : cards) {

src/test/java/domain/CardBundleTest.java

@@ -0,0 +1,58 @@
+package domain;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+public class CardBundleTest {
+
+    private CardBundle cardBundle;
+
+    @BeforeEach
+    void beforeEach() {
+        cardBundle = new CardBundle();
+    }
+
+    @DisplayName("일반 카드의 점수를 합산한다")
+    @Test
+    void 일반_카드의_점수를_합산한다() {
+        cardBundle.addCard(new Card(Rank.KING, Suit.SPADE));  // 10
+        cardBundle.addCard(new Card(Rank.FIVE, Suit.HEART));  // 5
+        assertThat(cardBundle.calculateScore()).isEqualTo(15);
+    }
+
+    @DisplayName("ACE가 있고 버스트가 아니면 11로 계산한다")
+    @Test
+    void ACE가_있고_버스트가_아니면_11로_계산한다() {
+        cardBundle.addCard(new Card(Rank.ACE, Suit.SPADE));   // 11
+        cardBundle.addCard(new Card(Rank.KING, Suit.HEART));  // 10
+        assertThat(cardBundle.calculateScore()).isEqualTo(21);
+    }
+
+    @DisplayName("ACE가 있고 버스트면 1로 계산한다")
+    @Test
+    void ACE가_있고_버스트면_1로_계산한다() {
+        cardBundle.addCard(new Card(Rank.ACE, Suit.SPADE));    // 1
+        cardBundle.addCard(new Card(Rank.KING, Suit.HEART));   // 10
+        cardBundle.addCard(new Card(Rank.FIVE, Suit.DIAMOND)); // 5
+        assertThat(cardBundle.calculateScore()).isEqualTo(16);
+    }
+
+    @DisplayName("ACE가 여러 장이면 하나만 11로 계산한다")
+    @Test
+    void ACE가_여러_장이면_하나만_11로_계산한다() {
+        cardBundle.addCard(new Card(Rank.ACE, Suit.SPADE));  // 11
+        cardBundle.addCard(new Card(Rank.ACE, Suit.HEART));  // 1
+        assertThat(cardBundle.calculateScore()).isEqualTo(12);
+    }
+
+    @Test
+    void 초기_두장이_21이면_블랙잭이다() {
+        cardBundle.addCard(new Card(Rank.KING, Suit.HEART)); // 10
+        cardBundle.addCard(new Card(Rank.ACE, Suit.SPADE)); // 11
+
+        assertThat(cardBundle.isBlackjack()).isTrue();
+    }
+}

src/test/java/domain/CardTest.java

@@ -4,7 +4,7 @@
 
 import org.junit.jupiter.api.Test;
 
-class CardTest {
+public class CardTest {
     @Test
     void 카드의_점수를_반환한다() {
         Card card = new Card(Rank.KING, Suit.SPADE);
@@ -16,4 +16,16 @@ class CardTest {
         Card card = new Card(Rank.ACE, Suit.HEART);
         assertThat(card.getScore()).isEqualTo(1);
     }
+
+    @Test
+    void ACE_카드는_isAce가_true이다() {
+        Card card = new Card(Rank.ACE, Suit.HEART);
+        assertThat(card.isAce()).isTrue();
+    }
+
+    @Test
+    void ACE가_아닌_카드는_isAce가_false이다() {
+        Card card = new Card(Rank.KING, Suit.SPADE);
+        assertThat(card.isAce()).isFalse();
+    }
 }