[Step4] : 🚀 4단계 - 블랙잭(베팅)

README.md

@@ -9,6 +9,7 @@
 - 입력
   - [x] 게임에 참여할 사람을 입력받는다.
   - [x] 한장의 카드를 더 받을지 말지 입력받는다.
+  - [x] 플레이어의 배팅 금액을 입력받는다.
 
 - 출력
   - [x] 플레이어가 가지고 있는 카드를 출력한다.
@@ -37,6 +38,19 @@
     - [x] 딜러는 처음에 받은 2장의 합계가 16이하라면 반드시 한장의 카드를 받는다.
       - [x] 16점 이하면 계속 카드를 뽑는다.
     - [x] 17점 이상이면 카드를 추가로 받을 수 없다.
+  - [x] 상태라는 클래스가 있다. 
+    - [x] 히트라는 상태가 있다
+      - [x] 히트는 먼저 받은 두 장의 합이 21에 못미치는 경우다.
+    - [x] 버스트라는 상태가 있다.
+      - [x] 버스트는 카드 총합이 21을 넘은 경우다.
+      - [] 카드를 추가로 뽑아 21을 초과하는 경우 배팅 금액을 모두 잃는다.
+      - [] 딜러가 버스트라면 남아 있는 플레이어들은 베팅 금액을 받는다.
+    - [x] 스탠드라는 상태가 있다.
+      - [x] 스탠드는 더 이상 카드를 뽑지 않는 경우다.
+    - [x] 블랙잭 이라는 생태가 있다.
+      - [x] 처음 받은 두 장의 카드의 총 합이 21이 되는 경우이다.
+      - [] 베팅 금액의 1.5배를 딜러에게 받는다.
+      - [] 딜러와 플레이어 동시에 블랙잭인 경우 플레이어는 베팅한 금액을 돌려받는다.
 
 ## 용어 정리
 
@@ -45,4 +59,8 @@
     - 플레이어가 버스트 당하면 패배가 확정된다.
     - 딜러가 버스트 당하면 그 시점까지 남아있는 모든 플레이어가 승리한다.
 - 블랙잭(Blackjack)
-  - A한장과 10, J, Q, L 로 21을 이루는 경우 베팅 금액의 1.5배를 돌려준다.
+  - A한장과 10, J, Q, L 로 21을 이루는 경우 베팅 금액의 1.5배를 돌려준다.
+- 히트(Hit)
+  - 먼저 받은 두 장의 합이 21에 못미치는 경우
+- 스탠드(Stand)
+  - 더 이상 카드를 뽑지 않고 넘어간 경우

src/main/kotlin/blackjack/GameManager.kt

@@ -1,6 +1,7 @@
 package blackjack
 
 import blackjack.card.CardDeck
+import blackjack.participant.BettingAmount
 import blackjack.participant.Dealer
 import blackjack.participant.Name
 import blackjack.participant.Player
@@ -23,17 +24,16 @@ class GameManager(
         players.forEach { it.drawCard(CardDeck.draw(FIRST_DRAW)) }
         dealer.drawCard(CardDeck.draw(FIRST_DRAW))
 
-        outputManager.printFirstTurn2(players)
+        outputManager.printFirstTurn(players)
         outputManager.printPlayersAndDealerCards(players, dealer)
 
         val result = playBlackJack()
 
+        outputManager.printDealerResultGame(dealer)
+
         players.forEach {
             outputManager.printPlayerResultGame(it)
         }
-
-        outputManager.printDealerResultGame(dealer)
-
         outputManager.printResult(result)
     }
 
@@ -62,15 +62,14 @@ class GameManager(
         while (dealer.shouldDraw()) {
             outputManager.printDealerCanDrawMessage()
             dealer.drawCard(CardDeck.draw(DRAW_CARD))
-            outputManager.printDealerCards(dealer)
         }
     }
 
     private fun playerChooseDraw(drawAmount: Int) = drawAmount > 0
 
     private fun joinPlayers(): List<Player> {
         val playerNames: List<String> = inputManager.inputPlayerNames()
-        return playerNames.map { Player(Name(it), ScoreCalculator()) }
+        return playerNames.map { Player(Name(it), BettingAmount(inputManager.inputBettingAmount(it))) }
     }
 
     private fun joinDealer(): Dealer {

src/main/kotlin/blackjack/GameResult.kt

@@ -1,35 +1,24 @@
 package blackjack
 
+import blackjack.participant.BettingAmount
 import blackjack.participant.Dealer
 import blackjack.participant.Name
 import blackjack.participant.Player
-import blackjack.participant.Result
 
 class GameResult(
     players: List<Player>,
     dealer: Dealer
 ) {
-    val resultMap: Map<Name, Result>
+    val resultMap: Map<Name, BettingAmount>
 
     init {
+        val playerResult = mutableMapOf<Name, BettingAmount>()
 
-        val (winCount, loseCount) = when {
-            dealer.isBust -> players.partition { !it.isBust }
-            else -> players.partition { it.resultScore() < dealer.resultScore() }
+        players.forEach {
+            val result = dealer.matchingScore(it)
+            playerResult[it.name] = it.status.calculateBettingAmount(result, it.bettingAmount)
         }
 
-        val playerResult = mutableMapOf<Name, Result>().apply {
-            winCount.map { this[it.name] = Result.Win() }
-            loseCount.map { this[it.name] = Result.Lose() }
-        }
-
-        resultMap = mapOf(
-            Name("딜러") to Result.DealerResult(winCount.size, loseCount.size)
-        ) + playerResult
-    }
-
-    companion object {
-        private const val WIN: String = "승"
-        private const val LOSE: String = "패"
+        resultMap = mapOf(Name("딜러") to dealer.bettingAmount) + playerResult
     }
 }

src/main/kotlin/blackjack/participant/BettingAmount.kt

@@ -0,0 +1,24 @@
+package blackjack.participant
+
+import kotlin.math.roundToInt
+
+@JvmInline
+value class BettingAmount(
+    val amount: Int
+) {
+    fun changeNegative(): BettingAmount {
+        return BettingAmount(amount * -1)
+    }
+
+    fun winToBlackjack(): BettingAmount {
+        return BettingAmount((amount * 1.5).roundToInt())
+    }
+
+    fun plusAmount(bettingAmount: BettingAmount): BettingAmount {
+        return BettingAmount(amount + bettingAmount.amount)
+    }
+
+    fun minusAmount(bettingAmount: BettingAmount): BettingAmount {
+        return BettingAmount(amount - bettingAmount.amount)
+    }
+}

src/main/kotlin/blackjack/participant/BlackjackStrategy.kt

@@ -2,23 +2,45 @@ package blackjack.participant
 
 import blackjack.ScoreCalculator
 import blackjack.card.BlackJackCard
+import blackjack.participant.status.Blackjack
+import blackjack.participant.status.Bust
+import blackjack.participant.status.Hit
+import blackjack.participant.status.Stand
+import blackjack.participant.status.Status
 
 class BlackjackStrategy(
     private val scoreCalculator: ScoreCalculator,
 ) {
     var cards: List<BlackJackCard> = emptyList()
+    var status: Status = Hit()
 
-    val isBust get() = resultScore() > BUST
+    val isBust get() = resultScore() > BLACKJACK
 
     fun drawCard(cards: List<BlackJackCard>) {
         this.cards += cards
+        changeStatus(cards)
     }
 
+    private fun changeStatus(cards: List<BlackJackCard>) {
+        when {
+            !isFirstTurn(cards) && !isBust -> status = Stand()
+            !isFirstTurn(cards) && isBust -> status = Bust()
+            isFirstTurn(cards) && isBlackjack() -> status = Blackjack()
+        }
+    }
+
+    private fun isFirstTurn(cards: List<BlackJackCard>): Boolean = cards.size == FIRST_TURN_DRAW
+
     fun resultScore(): Int {
         return scoreCalculator.calculateGameScore(cards)
     }
 
+    private fun isBlackjack(): Boolean {
+        return resultScore() == BLACKJACK
+    }
+
     companion object {
-        private const val BUST: Int = 21
+        private const val BLACKJACK: Int = 21
+        private const val FIRST_TURN_DRAW: Int = 2
     }
-}
+}

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

@@ -2,15 +2,18 @@ package blackjack.participant
 
 import blackjack.ScoreCalculator
 import blackjack.card.BlackJackCard
+import blackjack.participant.status.Blackjack
+import blackjack.participant.status.Bust
 
 class Dealer(
     scoreCalculator: ScoreCalculator
-)  {
+) {
     private val blackjackStrategy: BlackjackStrategy = BlackjackStrategy(scoreCalculator)
+    var bettingAmount: BettingAmount = BettingAmount(0)
 
     val cards get() = blackjackStrategy.cards
 
-    val isBust get() = blackjackStrategy.isBust
+    val status get() = blackjackStrategy.status
 
     fun drawCard(cards: List<BlackJackCard>) {
         blackjackStrategy.drawCard(cards)
@@ -24,6 +27,42 @@ class Dealer(
         return blackjackStrategy.resultScore() < MAX_DRAW_SCORE
     }
 
+    fun matchingScore(player: Player): Result {
+        if (player.status is Blackjack) {
+            return when (status) {
+                is Blackjack -> Result.Lose
+                else -> {
+                    bettingAmount = bettingAmount.minusAmount(
+                        player.status.calculateBettingAmount(
+                            Result.Win,
+                            player.bettingAmount
+                        )
+                    )
+                    return Result.Win
+                }
+            }
+        }
+
+        if (player.status is Bust) {
+            bettingAmount = bettingAmount.plusAmount(player.bettingAmount)
+            return Result.Lose
+        }
+
+        if (status is Bust) {
+            bettingAmount = bettingAmount.minusAmount(player.bettingAmount)
+            return Result.Win
+        }
+
+        return when (resultScore() > player.resultScore()) {
+            true -> {
+                bettingAmount = bettingAmount.plusAmount(player.bettingAmount)
+                Result.Lose
+            }
+
+            else -> Result.Win
+        }
+    }
+
     companion object {
         private const val MAX_DRAW_SCORE: Int = 17
     }

src/main/kotlin/blackjack/participant/Name.kt

@@ -3,4 +3,12 @@ package blackjack.participant
 @JvmInline
 value class Name(
     val value: String
-)
+) {
+    init {
+        require(value.isNotBlank()) { VALID_MESSAGE }
+    }
+
+    companion object {
+        private const val VALID_MESSAGE: String = "빈 값은 이름이 될 수 없습니다."
+    }
+}

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

@@ -5,14 +5,16 @@ import blackjack.card.BlackJackCard
 
 class Player(
     val name: Name,
-    scoreCalculator: ScoreCalculator
+    val bettingAmount: BettingAmount = BettingAmount(0),
+    scoreCalculator: ScoreCalculator = ScoreCalculator()
 ) {
+    constructor(name: Name, scoreCalculator: ScoreCalculator) : this(name, BettingAmount(0), scoreCalculator)
 
     private val blackjackStrategy: BlackjackStrategy = BlackjackStrategy(scoreCalculator)
 
     val cards get() = blackjackStrategy.cards
 
-    val isBust get() = blackjackStrategy.isBust
+    val status get() = blackjackStrategy.status
 
     fun drawCard(cards: List<BlackJackCard>) {
         blackjackStrategy.drawCard(cards)

src/main/kotlin/blackjack/participant/Result.kt

@@ -1,7 +1,6 @@
 package blackjack.participant
 
 sealed interface Result {
-    class Win : Result
-    class Lose : Result
-    class DealerResult(val win: Int, val lose: Int) : Result
+    object Win : Result
+    object Lose : Result
 }

src/main/kotlin/blackjack/participant/status/Blackjack.kt

@@ -0,0 +1,13 @@
+package blackjack.participant.status
+
+import blackjack.participant.BettingAmount
+import blackjack.participant.Result
+
+class Blackjack : Status {
+    override fun calculateBettingAmount(result: Result, bettingAmount: BettingAmount): BettingAmount {
+        return when(result) {
+            is Result.Win -> bettingAmount.winToBlackjack()
+            is Result.Lose -> BettingAmount(0)
+        }
+    }
+}

src/main/kotlin/blackjack/participant/status/Bust.kt

@@ -0,0 +1,10 @@
+package blackjack.participant.status
+
+import blackjack.participant.BettingAmount
+import blackjack.participant.Result
+
+class Bust : Status {
+    override fun calculateBettingAmount(result: Result, bettingAmount: BettingAmount): BettingAmount {
+        return bettingAmount.changeNegative()
+    }
+}

src/main/kotlin/blackjack/participant/status/Hit.kt

@@ -0,0 +1,13 @@
+package blackjack.participant.status
+
+import blackjack.participant.BettingAmount
+import blackjack.participant.Result
+
+class Hit : Status {
+    override fun calculateBettingAmount(result: Result, bettingAmount: BettingAmount): BettingAmount {
+        return when (result) {
+            is Result.Win -> bettingAmount
+            is Result.Lose -> bettingAmount.changeNegative()
+        }
+    }
+}

src/main/kotlin/blackjack/participant/status/Stand.kt

@@ -0,0 +1,13 @@
+package blackjack.participant.status
+
+import blackjack.participant.BettingAmount
+import blackjack.participant.Result
+
+class Stand : Status {
+    override fun calculateBettingAmount(result: Result, bettingAmount: BettingAmount): BettingAmount {
+        return when(result) {
+            is Result.Win -> bettingAmount
+            is Result.Lose -> bettingAmount.changeNegative()
+        }
+    }
+}

src/main/kotlin/blackjack/participant/status/Status.kt

@@ -0,0 +1,8 @@
+package blackjack.participant.status
+
+import blackjack.participant.BettingAmount
+import blackjack.participant.Result
+
+interface Status {
+    fun calculateBettingAmount(result: Result, bettingAmount: BettingAmount): BettingAmount
+}

src/main/kotlin/blackjack/ui/InputManager.kt

@@ -8,6 +8,12 @@ class InputManager {
         return inputUserValue().replace("\\s".toRegex(), "").split(",")
     }
 
+    fun inputBettingAmount(playerName: String): Int {
+        println()
+        println("${playerName}의 베팅 금액은?")
+        return inputUserValue().toInt()
+    }
+
     private fun inputUserValue(): String {
         val input = readln()
         require(input.isNotBlank()) { INPUT_NOT_NULL_MESSAGE }