[step4] 블랙잭 (베팅) & step3 코드리뷰 반영

README.md

@@ -19,4 +19,21 @@
 - 기능 요구사항 바탕으로 테스트코드 작성
 - 테스트코드 컴파일 되도록 코드 수정
 - 게임의 주체를 나타내는 Player 객체 정의 
-- 블랙잭 카드를 표현할 수 있는 객체 정의
+- 블랙잭 카드를 표현할 수 있는 객체 정의
+
+
+- 3단계 목록이 날라갔네 .. 
+
+### 4단계 구현 기능 목록 
+
+- [x] 플레이어는 게임을 시작할 때 베팅 금액을 정해야 한다. 
+- 베팅 관련 규칙 추가 
+  - [x] 카드를 추가로 뽑아 21을 초과할 경우 베팅 금액을 모두 잃게 된다.
+  - [x] 처음 두 장의 카드 합이 21일 경우 블랙잭이 되면 베팅 금액의 1.5 배를 딜러에게 받는다. 
+  - [x] 딜러와 플레이어가 모두 동시에 블랙잭인 경우 플레이어는 베팅한 금액을 돌려받는다.
+  - [x] 딜러가 21을 초과하면 그 시점까지 남아 있던 플레이어들은 가지고 있는 패에 상관 없이 승리해 베팅 금액을 받는다.
+
+### 4단계 프로그래밍 요구사항
+- 모든 엔티티를 작게 유지한다.
+- 3개 이상의 인스턴스 변수를 가진 클래스를 쓰지 않는다.
+- 딜러와 플레이어에서 발생하는 중복 코드를 제거해야 한다.

src/main/kotlin/blackjack/controller/BlackJackController.kt

@@ -22,6 +22,7 @@ object BlackJackController {
         val players =
             dealer.initPlayers(
                 fetchPlayerNames = { InputView.readPlayerNames() },
+                getBettingAmount = { name -> InputView.readBettingAmount(name) },
                 onPlayerInit = { names ->
                     ResultView.printPlayerInitMessage(names)
                     ResultView.printDealerWithCard(dealer.getCardForInitialDisplay())
@@ -59,8 +60,7 @@ object BlackJackController {
         players.onEach { player ->
             ResultView.printFinalScoresForPlayer(player)
         }
-
-        val result = BlackJackResultManager(dealer, players).getResult()
-        ResultView.printFinalWinLose(result)
+        val result = BlackJackResultManager(dealer, players).getResultV2()
+        ResultView.printFinalProfit(result)
     }
 }

src/main/kotlin/blackjack/domain/BetMoney.kt

@@ -0,0 +1,23 @@
+package blackjack.domain
+
+import java.math.BigDecimal
+import java.math.RoundingMode
+
+@JvmInline
+value class BetMoney(private val amount: BigDecimal) {
+    fun getOriginalBetAmount(): BigDecimal {
+        return amount
+    }
+
+    fun getAmountOnBlackJack(): BigDecimal {
+        return amount.multiply((1.5).toBigDecimal()).setScale(0, RoundingMode.DOWN)
+    }
+
+    fun getAmountOnBust(): BigDecimal {
+        return -(amount)
+    }
+
+    fun getAmountOnLose(): BigDecimal {
+        return -(amount)
+    }
+}

src/main/kotlin/blackjack/domain/BlackJackResultManager.kt

@@ -3,31 +3,52 @@ package blackjack.domain
 class BlackJackResultManager(
     private val dealer: Dealer,
     private val players: Players,
-    private val playerResultCalculator: PlayerResultCalculator = PlayerResultCalculator(),
 ) {
+    @Deprecated("step4에서는 getResultV2 를 사용하세요 - step3 에서만 사용됨")
     fun getResult(): BlackJackResult {
         val dealerScore = dealer.cardsSum
         val playersWinLose =
             players.value.associateWith { player ->
-                playerResultCalculator.calculate(dealerScore, player.cardsSum)
+                PlayerResultCalculator.calculate(dealerScore, player.cardsSum)
             }
 
-        val dealerWinCount = playersWinLose.count { it.value == PlayerResult.LOSE }
-        val dealerLoseCount = playersWinLose.count { it.value == PlayerResult.WIN }
-        return BlackJackResult(dealerWinCount, dealerLoseCount, PlayerToResultMap(playersWinLose))
+        return BlackJackResult(PlayerToResultMap(playersWinLose))
+    }
+
+    fun getResultV2(): BlackJackResultV2 {
+        val playersProfits = players.getPlayersToProfitMoney(
+            getGameResult = { player -> player.getGameResultWith(dealer) },
+            onSetPlayerProfitMoney = { profitMoney -> dealer.adjustProfit(profitMoney) }
+        )
+        return BlackJackResultV2(dealer.profitMoney, playersProfits)
     }
 }
 
+data class BlackJackResultV2(
+    val dealerProfitMoney: ProfitMoney,
+    val playerToProfit: PlayerToProfitMoney,
+)
+
+data class PlayerToProfitMoney(val value: Map<Player, ProfitMoney>)
+
+@Deprecated("deprecated - step3 에서만 사용됨")
 data class BlackJackResult(
-    val dealerWinCount: Int,
-    val dealerLoseCount: Int,
     val playerToResultMap: PlayerToResultMap,
-)
+) {
+    val dealerWinCount: Int
+        get() = playerToResultMap.getPlayerLoseCounts()
+    val dealerLoseCount: Int
+        get() = playerToResultMap.getPlayerWinningCounts()
+}
 
+@Deprecated("deprecated - step3 에서만 사용됨")
 @JvmInline
-value class PlayerToResultMap(val value: Map<Player, PlayerResult>)
+value class PlayerToResultMap(val value: Map<Player, GameResult>) {
+    fun getPlayerWinningCounts(): Int {
+        return value.count { it.value == GameResult.WIN }
+    }
 
-enum class PlayerResult {
-    WIN,
-    LOSE,
+    fun getPlayerLoseCounts(): Int {
+        return value.count { it.value == GameResult.LOSE }
+    }
 }

src/main/kotlin/blackjack/domain/Card.kt

@@ -3,14 +3,6 @@ package blackjack.domain
 data class Card(val rank: Rank, val suit: Suit) {
     private fun isAce() = rank == Rank.ACE
 
-    fun isOverMaxSum(currentCardSum: Int): Boolean {
-        return if (isAce()) {
-            currentCardSum + ACE_VALUE_ONE > MAX_SUM && currentCardSum + this.rank.value > MAX_SUM
-        } else {
-            currentCardSum + this.rank.value > MAX_SUM
-        }
-    }
-
     companion object {
         const val ACE_VALUE_ONE = 1
         const val MAX_SUM = 21

src/main/kotlin/blackjack/domain/Dealer.kt

@@ -1,32 +1,51 @@
 package blackjack.domain
 
+import java.math.BigDecimal
+
 class Dealer(
     private val drawCard: () -> Card,
 ) : Participant(drawCard = drawCard) {
     fun initPlayers(
         fetchPlayerNames: () -> List<String>,
+        getBettingAmount: (String) -> BigDecimal,
         onPlayerInit: (List<String>) -> Unit,
     ): Players {
         val names = fetchPlayerNames()
-        val players = names.map { name -> Player(name = name, drawCard = drawCard) }
+        val nameAndBets = names.associateWith(getBettingAmount)
+        val players =
+            Players(
+                nameAndBets.map { (name, bet) ->
+                    Player(
+                        name = name,
+                        betMoney = BetMoney(bet),
+                        drawCard = drawCard,
+                    )
+                },
+            )
         onPlayerInit(names)
-        return Players(value = players)
+        return players
     }
 
     fun drawOneMoreCardIfNeeded(onDrawCard: () -> Unit) {
-        addCardIfAvailable(requireCard = { drawCard() }, onDrawCard = onDrawCard)
+        addCardIfAvailable(requireCard = drawCard, onDrawCard = onDrawCard)
     }
 
     override fun isAddCardEnabled(): Boolean {
-        return cardsSum <= 16
+        return cardsSum <= DEALER_DRAW_ONE_MORE_CARD_THRESHOLD
     }
 
     fun getCardForInitialDisplay(): Card {
         require(cards.value.isNotEmpty()) { "Dealer should be initialized with $DEALER_CARD_COUNT cards." }
         return cards.value[0]
     }
 
+    fun adjustProfit(playerProfit: ProfitMoney) {
+        val profit = profitMoney.getCurrentProfit() - playerProfit.getCurrentProfit()
+        profitMoney.set(profit)
+    }
+
     companion object {
         private const val DEALER_CARD_COUNT = 2
+        private const val DEALER_DRAW_ONE_MORE_CARD_THRESHOLD = 16
     }
 }

src/main/kotlin/blackjack/domain/GameResult.kt

@@ -0,0 +1,25 @@
+package blackjack.domain
+
+enum class GameResult {
+    WIN,
+    BUST,
+    LOSE,
+    PUSH,
+    BLACK_JACK,
+    ;
+
+    companion object {
+        fun fromScores(
+            dealerScore: Int,
+            playerScore: Int,
+        ): GameResult {
+            return when {
+                dealerScore > Card.MAX_SUM -> WIN // Dealer bust
+                playerScore > Card.MAX_SUM -> BUST // Player bust
+                dealerScore > playerScore -> LOSE
+                playerScore > dealerScore -> WIN
+                else -> PUSH
+            }
+        }
+    }
+}

src/main/kotlin/blackjack/domain/Participant.kt

@@ -2,14 +2,16 @@ package blackjack.domain
 
 abstract class Participant(
     private val drawCard: () -> Card,
-    initialCardCount: Int = 2,
 ) {
     private val _cards = mutableListOf<Card>()
     val cards: Cards = Cards(_cards)
     val cardsSum: Int get() = cards.sumValues()
+    val profitMoney: ProfitMoney = ProfitMoney()
+    val isBlackJackInitially: Boolean
 
     init {
-        repeat(initialCardCount) { addCard(drawCard()) }
+        repeat(INITIAL_CARD_COUNT) { addCard(drawCard()) }
+        isBlackJackInitially = cardsSum == Card.MAX_SUM
     }
 
     private fun addCard(card: Card) {
@@ -29,4 +31,8 @@ abstract class Participant(
     }
 
     abstract fun isAddCardEnabled(): Boolean
+
+    companion object {
+        private const val INITIAL_CARD_COUNT = 2
+    }
 }

src/main/kotlin/blackjack/domain/Player.kt

@@ -1,25 +1,53 @@
 package blackjack.domain
 
+import java.math.BigDecimal
+
 class Player(
     val name: String,
+    private val betMoney: BetMoney,
     private val drawCard: () -> Card,
 ) : Participant(drawCard = drawCard) {
-    private lateinit var currentCard: Card
-
     fun play(
         isDrawCard: (String) -> Boolean,
         onDrawCard: () -> Unit,
         onExitPlay: () -> Unit,
     ) {
-        while (isDrawCard(name)) {
-            currentCard = drawCard()
-            val isCardAdded = addCardIfAvailable(requireCard = { currentCard }, onDrawCard = onDrawCard)
-            if (isCardAdded.not()) break
+        var shouldContinue = shouldContinueDrawing(isDrawCard)
+        while (shouldContinue) {
+            val isCardAdded = addCardIfAvailable(requireCard = drawCard, onDrawCard = onDrawCard)
+            shouldContinue = isCardAdded && shouldContinueDrawing(isDrawCard)
         }
         onExitPlay()
     }
 
+    fun getGameResultWith(dealer: Dealer): GameResult {
+        return when {
+            this.isBlackJackInitially && dealer.isBlackJackInitially.not() -> GameResult.BLACK_JACK
+            this.isBlackJackInitially && dealer.isBlackJackInitially -> GameResult.PUSH
+            else -> GameResult.fromScores(dealer.cardsSum, this.cardsSum)
+        }
+    }
+
+    fun setProfitMoneyFromGameResult(result: GameResult) {
+        val betMoney = getBetMoneyFromGameResult(result)
+        profitMoney.set(betMoney)
+    }
+
+    private fun getBetMoneyFromGameResult(gameResult: GameResult): BigDecimal {
+        return when (gameResult) {
+            GameResult.BLACK_JACK -> betMoney.getAmountOnBlackJack()
+            GameResult.WIN -> betMoney.getOriginalBetAmount()
+            GameResult.PUSH -> betMoney.getOriginalBetAmount()
+            GameResult.LOSE -> betMoney.getAmountOnLose()
+            GameResult.BUST -> betMoney.getAmountOnBust()
+        }
+    }
+
+    private fun shouldContinueDrawing(isDrawCard: (String) -> Boolean): Boolean {
+        return isDrawCard(name)
+    }
+
     override fun isAddCardEnabled(): Boolean {
-        return currentCard.isOverMaxSum(cardsSum).not()
+        return cardsSum < Card.MAX_SUM
     }
 }

src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt

@@ -1,15 +1,17 @@
 package blackjack.domain
 
-class PlayerResultCalculator {
+@Deprecated("deprecated - step3 에서만 사용됨")
+object PlayerResultCalculator {
     fun calculate(
         dealerScore: Int,
         playerScore: Int,
-    ): PlayerResult {
+    ): GameResult {
         return when {
-            dealerScore > 21 -> PlayerResult.WIN
-            playerScore > 21 -> PlayerResult.LOSE
-            playerScore > dealerScore -> PlayerResult.WIN
-            else -> PlayerResult.LOSE
+            dealerScore > Card.MAX_SUM -> GameResult.WIN
+            playerScore > Card.MAX_SUM -> GameResult.BUST
+            dealerScore > playerScore -> GameResult.LOSE
+            playerScore > dealerScore -> GameResult.WIN
+            else -> GameResult.PUSH
         }
     }
 }

src/main/kotlin/blackjack/domain/Players.kt

@@ -2,17 +2,31 @@ package blackjack.domain
 
 data class Players(val value: List<Player>) {
     fun onEachPreparePlay(action: (Player) -> Unit): Players {
-        value.forEach { action(it) }
+        onEach(action)
         return this
     }
 
     fun onEachStartPlay(action: (Player) -> Unit): Players {
-        value.forEach { action(it) }
+        onEach(action)
         return this
     }
 
     fun onEach(action: (Player) -> Unit): Players {
         value.forEach { action(it) }
         return this
     }
+
+    fun getPlayersToProfitMoney(
+        getGameResult: (Player) -> GameResult,
+        onSetPlayerProfitMoney: (ProfitMoney) -> Unit
+    ): PlayerToProfitMoney {
+        val map =
+            value.associateWith { player ->
+                val gameResult = getGameResult(player)
+                player.setProfitMoneyFromGameResult(gameResult)
+                onSetPlayerProfitMoney(player.profitMoney)
+                player.profitMoney
+            }
+        return PlayerToProfitMoney(map)
+    }
 }

src/main/kotlin/blackjack/domain/ProfitMoney.kt

@@ -0,0 +1,15 @@
+package blackjack.domain
+
+import java.math.BigDecimal
+
+class ProfitMoney {
+    private var current: BigDecimal = BigDecimal.ZERO
+
+    fun getCurrentProfit(): BigDecimal {
+        return current
+    }
+
+    fun set(amount: BigDecimal) {
+        current = amount
+    }
+}