[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.getResult(dealer, players)
+        ResultView.printFinalProfit(result)
     }
 }

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

@@ -0,0 +1,34 @@
+package blackjack.domain
+
+import blackjack.domain.GameResult.*
+import java.math.BigDecimal
+import java.math.RoundingMode
+
+@JvmInline
+value class BetMoney(private val amount: BigDecimal) {
+    fun getAmount(gameResult: GameResult): BigDecimal {
+        return when (gameResult) {
+            BLACK_JACK -> getAmountOnBlackJack()
+            WIN -> getOriginalBetAmount()
+            PUSH -> getOriginalBetAmount()
+            LOSE -> getAmountOnLose()
+            BUST -> getAmountOnBust()
+        }
+    }
+
+    private fun getOriginalBetAmount(): BigDecimal {
+        return amount
+    }
+
+    private fun getAmountOnBlackJack(): BigDecimal {
+        return amount.multiply((1.5).toBigDecimal()).setScale(0, RoundingMode.DOWN)
+    }
+
+    private fun getAmountOnBust(): BigDecimal {
+        return -(amount)
+    }
+
+    private fun getAmountOnLose(): BigDecimal {
+        return -(amount)
+    }
+}

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

@@ -1,33 +1,27 @@
 package blackjack.domain
 
-class BlackJackResultManager(
-    private val dealer: Dealer,
-    private val players: Players,
-    private val playerResultCalculator: PlayerResultCalculator = PlayerResultCalculator(),
-) {
-    fun getResult(): BlackJackResult {
-        val dealerScore = dealer.cardsSum
-        val playersWinLose =
-            players.value.associateWith { player ->
-                playerResultCalculator.calculate(dealerScore, player.cardsSum)
-            }
+import java.math.BigDecimal
 
-        val dealerWinCount = playersWinLose.count { it.value == PlayerResult.LOSE }
-        val dealerLoseCount = playersWinLose.count { it.value == PlayerResult.WIN }
-        return BlackJackResult(dealerWinCount, dealerLoseCount, PlayerToResultMap(playersWinLose))
+object BlackJackResultManager {
+    fun getResult(
+        dealer: Dealer,
+        players: Players,
+    ): BlackJackResult {
+        val playersProfits =
+            players.getPlayersToProfitMoney(
+                dealer.isBlackJackInitially,
+                dealer.cardsSum,
+            )
+        return BlackJackResult(playersProfits)
     }
 }
 
 data class BlackJackResult(
-    val dealerWinCount: Int,
-    val dealerLoseCount: Int,
-    val playerToResultMap: PlayerToResultMap,
-)
-
-@JvmInline
-value class PlayerToResultMap(val value: Map<Player, PlayerResult>)
+    val playerToProfit: PlayerToProfitMoney,
+) {
+    val dealerProfitMoney: ProfitMoney get() = ProfitMoney().apply { set(-playerToProfit.getAllProfitSum) }
+}
 
-enum class PlayerResult {
-    WIN,
-    LOSE,
+data class PlayerToProfitMoney(val value: Map<Player, ProfitMoney>) {
+    val getAllProfitSum: BigDecimal get() = value.values.sumOf { it.getCurrentProfit() }
 }

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,24 +1,37 @@
 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 {
@@ -28,5 +41,6 @@ class Dealer(
 
     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,38 @@
+package blackjack.domain
+
+enum class GameResult {
+    WIN,
+    BUST,
+    LOSE,
+    PUSH,
+    BLACK_JACK,
+    ;
+
+    companion object {
+        fun getGameResultsWith(
+            isPlayerBlackJackInitially: Boolean,
+            isDealerBlackJackInitially: Boolean,
+            dealerCardSum: Int,
+            playerCardSum: Int,
+        ): GameResult {
+            return when {
+                isPlayerBlackJackInitially && isDealerBlackJackInitially.not() -> BLACK_JACK
+                isPlayerBlackJackInitially && isDealerBlackJackInitially -> PUSH
+                else -> fromScores(dealerCardSum, playerCardSum)
+            }
+        }
+
+        private 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,15 @@ 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 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 +30,8 @@ abstract class Participant(
     }
 
     abstract fun isAddCardEnabled(): Boolean
+
+    companion object {
+        private const val INITIAL_CARD_COUNT = 2
+    }
 }

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

@@ -2,24 +2,35 @@ package blackjack.domain
 
 class Player(
     val name: String,
+    private val betMoney: BetMoney,
     private val drawCard: () -> Card,
 ) : Participant(drawCard = drawCard) {
-    private lateinit var currentCard: Card
+    private val profitMoney: ProfitMoney = ProfitMoney()
 
     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 getProfitMoney(gameResult: GameResult): ProfitMoney {
+        val betMoneyAmount = betMoney.getAmount(gameResult)
+        profitMoney.set(betMoneyAmount)
+        return profitMoney
+    }
+
+    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/Players.kt

@@ -2,17 +2,35 @@ 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(
+        isDealerBlackJack: Boolean,
+        dealerCardSum: Int,
+    ): PlayerToProfitMoney {
+        return PlayerToProfitMoney(
+            value.associateWith { player ->
+                val gameResult =
+                    GameResult.getGameResultsWith(
+                        isPlayerBlackJackInitially = player.isBlackJackInitially,
+                        isDealerBlackJackInitially = isDealerBlackJack,
+                        dealerCardSum = dealerCardSum,
+                        playerCardSum = player.cardsSum,
+                    )
+                player.getProfitMoney(gameResult)
+            },
+        )
+    }
 }

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
+    }
+}

src/main/kotlin/blackjack/view/InputView.kt

@@ -1,5 +1,7 @@
 package blackjack.view
 
+import java.math.BigDecimal
+
 object InputView {
     fun readPlayerNames(): List<String> {
         println("\n* 게임에 참여할 사람의 이름을 임력하세요 (쉼표 기준으로 분리)")
@@ -10,6 +12,13 @@ object InputView {
         return names
     }
 
+    fun readBettingAmount(name: String): BigDecimal {
+        println("\n* $name 의 베팅 금액은?")
+        val amount =
+            readlnOrNull()?.trim()?.toBigDecimalOrNull() ?: throw IllegalStateException("Invalid Betting amount")
+        return amount
+    }
+
     fun readIsDrawMore(name: String): Boolean {
         println("\n* $name 는 한 장의 카드를 더 받겠습니까? (예는 y, 아니오는 n)")
         val yesOrNo = readlnOrNull()?.trim() ?: "n"