[2단계 - 블랙잭(베팅)] 테오(최우성) 미션 제출합니다.

README.md

@@ -30,13 +30,14 @@
 - [x] 플레이어
   - [x] 이름을 가진다
   - [x] 카드들을 가진다
+  - [x] 배팅 금액을 가질 수 있다
   - [x] 가지고 있는 카드의 숫자를 계산할 수 있다
-  - [x] 다른 사람의 점수와 비교할 수 있다
   - [x] 카드를 한장 받는다
-    
+
 - [x] 딜러
   - [x] 딜러는 플레이어이다 
   - [x] 카드의 합이 임계값보다 작거나 같으면 히트이다
+  - [x] 딜러는 카드를 1장 덜 보여준다
 
 - [x] 이름
   - [x] 1~5자의 길이만 허용된다
@@ -46,33 +47,68 @@
   - [x] 숫자를 가진다
 
 - [x] 덱
-  - [x] 숫자 위치의 카드를 반환한다
   - [x] 모든 카드를 가진다
+  - [x] 카드를 섞는다
+  - [x] 카드를 한 장 반환한다
 
 - [x] 카드풀
   - [x] 카드를 가질 수 있다
   - [x] 카드 숫자의 합을 계산한다.
     - [x] 에이스는 11일 때 숫자의 합이 21이 넘으면 1로 계산한다
+  - [x] 에이스가 있는지 판단할 수 있다.
 
 - [x] 블랙잭 게임
-  - [x] 모든 참여자와 딜러의 승패를 가지고 있다 
-  - [x] 모든 딜러와 참여자에게 카드를 뽑는 명령을 내린다
-  - [x] 모든 카드를 받아서 숫자를 비교한다
   - [x] 덱을 초기화 한다
-  - [x] 21(버스트 숫자)을 넘으면 버스트(죽는다). 
-
-- [x] 숫자 생성기
-  - [x] 랜덤으로 숫자를 생성한다
-
-## 객체 다이어그램
-
-<img src="diagram.png" style="width: 80%; height= 80%">
-
-
+  - [x] 모든 딜러와 참여자에게 카드를 뽑는 명령을 내린다
+  - [x] 모든 참여자와 딜러의 승패를 알고 있다
+  - [x] 하나 이상의 플레이어가 이기면, 딜러는 각각의 플레이어의 총 배팅 금액만큼을 잃는다
+    - [ ] 어떤 플레이어의 처음 두 장의 카드가 블랙잭이면, 1.5배를 잃는다
+      - [ ] 딜러와 플레이어 모두가 블랙잭이라면 아무도 잃지 않는다
+  - [x] 딜러가 이기면, 상대 플레이어는 배팅 금액을 전부 잃는다 
+
+- [x] 카드 섞기 규칙
+  - [x] 랜덤으로 섞는다
+
+## 객체 다이어그램(초기 설계)
+
+<img src="diagram.png" style="width: 80%; height: 80%">
+
+## Main Dependency Graph
+
+```mermaid
+classDiagram
+    BlackjackController-->ClientCommand
+    BlackjackController-->InputView
+    BlackjackController-->OutputView
+    BlackjackController-->BlackjackGame
+    BlackjackGame-->Deck
+    BlackjackGame-->GameParticipant
+    Deck-->ShuffleStrategy
+    GameParticipant-->Player
+    GameParticipant-->Dealer
+    GameParticipant-->GameResult
+    Player-->Bet
+    Player-->CardPool
+    Player-->PlayerName
+    Dealer-->Bet
+    Dealer-->CardPool
+    Dealer-->PlayerName
+
+```
 
 ### 고민사항
 - DeckMaker 객체를 둘지, Deck 안에서 생성 책임까지 가질지?
 - 플레이어들을 getter를 사용해 가져와 반복문을 돌리는 경우가 있는데, Iterator 생성은 어떤가?
   내부 구현은 숨기면서, 내부에 접근할 수 있다는 점에서 좋은 것 같은데, 만들기에는 너무 오버헤드가 큰지 고민임.
 - 개발자들을 위해 존재하는 예외 메세지는 개발자만 이해할 수 있도록 정보를 제공해도 될까?
-- 
+
+### 2단계 고민사항
+- TDD 사이클에서 ParameterizedTest를 사용해도 될까? ParameterizedTest를 사용하면 여러 케이스를 동시에 검증하기에 TDD에 부적절하지는 않을까?
+- `딜러는 처음에 한 장의 카드를 숨겨야 한다`는 요구사항을 잊고 있다가 구현하고 보니 getter에서 리스트를 변형하는 등 많은 작업을 하고 있는 것 같다. 괜찮을까?
+- 요구사항 중 `인스턴스 변수를 3개 이상 쓰지 않는다`가 있었다. 하지만 플레이어가 배팅 금액을 가지는 과정에서 인스턴스 변수가 3개가 되어버린다. <br>
+  그렇다고 해서 배팅 금액을 Player에서 분리하느냐? 이것은 예측하기 어려운 설계라고 생각한다. 프로그래밍 요구사항을 어기는 것은 금기인가? 좋은 설계가 우선이 아닐까?
+- void 타입 메소드를 선호하는데, 괜찮은걸까? 객체지향에서 사실 void 타입은 존재하지 않아도 되는데.
+- fixture를 처음 사용함. 다만 fixture 안에 값에 맞는 enum 객체를 찾기 위한 로직이 들어가게 됨. 괜찮을까?
+- blackjackGame 객체에서 `hitFor` 메소드에서 Player를 인자로 받기에, 바로 player.draw로 히트하는 책임을 수행할 수 있음. 다만 이렇게 하는 경우 <br>
+  blackjackGame에서 Player 객체와의 의존성이 생겨버림. blackjackGame은 gameParticipant에 인자만 넘겨주면서, 의존성을 줄이는게 좋은 전략 아닐까? 
+- 의존성은 import문의 개수로 취급되어야 할까? 그렇게 판단하면 의존성이 너무 많다고 생각하는데.. 잘못된 설계인가?

src/main/java/controller/BlackJackController.java

@@ -2,6 +2,7 @@
 
 import domain.game.BlackjackGame;
 import domain.strategy.RandomShuffleStrategy;
+import domain.user.Dealer;
 import domain.user.GameParticipant;
 import domain.user.Player;
 import view.InputView;
@@ -24,27 +25,38 @@ public void run() {
         try {
             initializeGame();
             startGame();
-        } catch (RuntimeException e) {
+        } catch (IllegalArgumentException e) {
             outputView.printExceptionMessage(e.getMessage());
         }
     }
 
     private void initializeGame() {
         List<String> playersName = inputView.inputParticipantsName();
-        blackjackGame = new BlackjackGame(playersName, "딜러", new RandomShuffleStrategy());
+        blackjackGame = new BlackjackGame(playersName, new RandomShuffleStrategy());
     }
 
     private void startGame() {
-        blackjackGame.startHit();
+        List<Player> players = blackjackGame.getGameParticipant().getPlayers();
+        Dealer dealer = blackjackGame.getGameParticipant().getDealer();
+
+        startBet(players);
+        startHit();
+        outputView.printPlayersInfoWhenGameStarted(dealer, players);
 
-        GameParticipant gameParticipant = blackjackGame.getGameParticipant();
-        outputView.printPlayersInfoWhenGameStarted(gameParticipant.getDealer(), gameParticipant.getPlayers());
+        letPlayerChoiceWhetherHit(players);
+        blackjackGame.updateBetAmount();
+        printGameResult(players, dealer);
+    }
 
-        letPlayerChoiceWhetherHit(gameParticipant.getPlayers());
-        outputView.printGameScore(gameParticipant.getDealer(), gameParticipant.getPlayers());
+    private void startBet(final List<Player> players) {
+        for (Player player : players) {
+            int amount = inputView.inputBetAmount(player.getPlayerName().getName());
+            player.addAmount(amount);
+        }
+    }
 
-        outputView.printDealerRecord(gameParticipant.getDealer(), blackjackGame.getDealerRecord());
-        outputView.printPlayerRecord(blackjackGame.getGameResultForAllPlayer());
+    private void startHit() {
+        blackjackGame.startHit();
     }
 
     private void letPlayerChoiceWhetherHit(List<Player> players) {
@@ -65,7 +77,7 @@ private void hitByPlayerChoice(Player player) {
     }
 
     private boolean needToQuit(Player player) {
-        if (blackjackGame.isBurst(player)) {
+        if (player.isBurst()) {
             return true;
         }
 
@@ -81,4 +93,8 @@ private void hitByDealer() {
         }
     }
 
+    private void printGameResult(final List<Player> players, final Dealer dealer) {
+        outputView.printGameScore(dealer, players);
+        outputView.printRevenueForAll(dealer, players);
+    }
 }

src/main/java/domain/game/BlackjackGame.java

@@ -5,7 +5,6 @@
 import domain.user.Player;
 
 import java.util.List;
-import java.util.Map;
 
 public class BlackjackGame {
 
@@ -16,11 +15,10 @@ public class BlackjackGame {
 
     public BlackjackGame(
             final List<String> playerNames,
-            final String dealerName,
             final ShuffleStrategy shuffleStrategy
     ) {
         this.deck = new Deck(shuffleStrategy);
-        this.gameParticipant = new GameParticipant(playerNames, dealerName);
+        this.gameParticipant = new GameParticipant(playerNames);
     }
 
     public void letDealerHitUntilThreshold() {
@@ -37,20 +35,12 @@ public void startHit() {
         }
     }
 
-    public boolean isBurst(final Player player) {
-        return gameParticipant.isBurst(player);
-    }
-
     public void hitFor(final Player player) {
-        gameParticipant.letPlayerToHit(player, deck);
-    }
-
-    public Map<Player, GameResult> getGameResultForAllPlayer() {
-        return gameParticipant.makeGameResultForAllPlayer();
+        player.draw(deck.serve());
     }
 
-    public Map<GameResult, Integer> getDealerRecord() {
-        return gameParticipant.getDealerRecord(getGameResultForAllPlayer());
+    public void updateBetAmount() {
+        gameParticipant.updateBetAmountByGameResult();
     }
 
     public GameParticipant getGameParticipant() {

src/main/java/domain/game/Deck.java

@@ -41,7 +41,7 @@ private static List<Card> makeCardsOfOneCardType(final CardType cardType) {
     }
 
     public Card serve() {
-        shuffleStrategy.shuffle(cards);
-        return cards.get(TOP_CARD);
+        List<Card> shuffledCards = shuffleStrategy.shuffle(cards);
+        return shuffledCards.get(TOP_CARD);
     }
 }

src/main/java/domain/game/GameResult.java

@@ -47,4 +47,12 @@ public static Map<GameResult, Integer> makeDealerRecord(final Map<Player, GameRe
     private static int countGameResult(final Collection<GameResult> gameResults, final GameResult gameResultType) {
         return Collections.frequency(gameResults, gameResultType);
     }
+
+    public boolean isWin() {
+        return this == WIN;
+    }
+
+    public boolean isLose() {
+        return this == LOSE;
+    }
 }

src/main/java/domain/strategy/RandomShuffleStrategy.java

@@ -2,13 +2,16 @@
 
 import domain.card.Card;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
 public class RandomShuffleStrategy implements ShuffleStrategy {
 
     @Override
-    public void shuffle(final List<Card> cards) {
-        Collections.shuffle(cards);
+    public List<Card> shuffle(final List<Card> cards) {
+        List<Card> shuffledCards = new ArrayList<>(cards);
+        Collections.shuffle(shuffledCards);
+        return shuffledCards;
     }
 }

src/main/java/domain/strategy/ShuffleStrategy.java

@@ -6,5 +6,5 @@
 
 public interface ShuffleStrategy {
 
-    void shuffle(final List<Card> cards);
+    List<Card> shuffle(final List<Card> cards);
 }

src/main/java/domain/user/Bet.java

@@ -0,0 +1,38 @@
+package domain.user;
+
+public class Bet {
+
+    private static final double REVENUE_BONUS_RATE = 1.5;
+
+    private int credit;
+    private int revenue;
+
+    public Bet(final int credit) {
+        this.credit = credit;
+        this.revenue = 0;
+    }
+
+    public void addAmount(int amount) {
+        this.credit += amount;
+    }
+
+    public void addRevenue() {
+        revenue += credit;
+    }
+
+    public void addBonusRevenue() {
+        revenue += credit * REVENUE_BONUS_RATE;
+    }
+
+    public void decreaseRevenue() {
+        revenue -= credit;
+    }
+
+    public void payFor(final Bet otherBet) {
+        revenue -= otherBet.revenue;
+    }
+
+    public int getRevenue() {
+        return revenue;
+    }
+}

src/main/java/domain/user/CardPool.java

@@ -55,4 +55,8 @@ private boolean containsAce() {
     public List<Card> getCards() {
         return Collections.unmodifiableList(cards);
     }
+
+    public boolean isSumSameAsLimit() {
+        return sumCardNumbers() == CARD_POINT_LIMIT;
+    }
 }

src/main/java/domain/user/Dealer.java

@@ -1,14 +1,27 @@
 package domain.user;
 
+import domain.card.Card;
+
+import java.util.List;
+
 public class Dealer extends Player {
 
     private static final int DEALER_THRESHOLD = 16;
+    private static final int NUMBERS_OF_CARDS_TO_HIDE = 1;
+    private static final int DEPOSIT = 100_000;
+
+    private static final String DEFAULT_NAME = "딜러";
 
-    public Dealer(final String playerName, final CardPool cardPool) {
-        super(playerName, cardPool);
+    public Dealer(final CardPool cardPool) {
+        super(DEFAULT_NAME, cardPool, DEPOSIT);
     }
 
     public boolean needsHit() {
         return sumCardPool() <= DEALER_THRESHOLD;
     }
+
+    public CardPool getHiddenCardPool() {
+        List<Card> originalCards = super.getCardPool().getCards();
+        return new CardPool(originalCards.subList(0, originalCards.size() - NUMBERS_OF_CARDS_TO_HIDE));
+    }
 }