[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,9 @@
 package blackjack
 
 import blackjack.card.CardDeck
+import blackjack.supoort.GameResultGenerator
+import blackjack.supoort.ScoreCalculator
+import blackjack.participant.BettingAmount
 import blackjack.participant.Dealer
 import blackjack.participant.Name
 import blackjack.participant.Player
@@ -23,27 +26,24 @@ 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()
+        playBlackJack()
 
-        players.forEach {
-            outputManager.printPlayerResultGame(it)
-        }
+        val result = GameResultGenerator.generateGameResult(players, dealer)
 
         outputManager.printDealerResultGame(dealer)
 
+        players.forEach(outputManager::printPlayerResultGame)
         outputManager.printResult(result)
     }
 
-    private fun playBlackJack(): GameResult {
+    private fun playBlackJack() {
         players.forEach {
             playerDraw(it)
         }
         dealerDraw(dealer)
-
-        return GameResult(players, dealer)
     }
 
     private fun playerDraw(player: Player) {
@@ -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/participant/BettingAmount.kt

@@ -0,0 +1,25 @@
+package blackjack.participant
+
+import kotlin.math.roundToInt
+
+@JvmInline
+value class BettingAmount(
+    val amount: Int
+) {
+
+    fun winToBlackjack(): BettingAmount {
+        return BettingAmount((amount * 1.5).roundToInt())
+    }
+
+    operator fun unaryMinus(): BettingAmount {
+        return BettingAmount(amount * -1)
+    }
+}
+
+infix operator fun BettingAmount.plus(bettingAmount: BettingAmount): BettingAmount {
+    return BettingAmount(amount + bettingAmount.amount)
+}
+
+infix operator fun BettingAmount.minus(bettingAmount: BettingAmount): BettingAmount {
+    return BettingAmount(amount - bettingAmount.amount)
+}

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

@@ -1,24 +1,48 @@
 package blackjack.participant
 
-import blackjack.ScoreCalculator
+import blackjack.supoort.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
+    fun isBust(): Boolean {
+        return 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

@@ -1,16 +1,15 @@
 package blackjack.participant
 
-import blackjack.ScoreCalculator
 import blackjack.card.BlackJackCard
+import blackjack.supoort.ScoreCalculator
 
 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)

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

@@ -1,18 +1,20 @@
 package blackjack.participant
 
-import blackjack.ScoreCalculator
+import blackjack.supoort.ScoreCalculator
 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)
@@ -23,6 +25,6 @@ class Player(
     }
 
     fun shouldDraw(): Boolean {
-        return !blackjackStrategy.isBust
+        return !blackjackStrategy.isBust()
     }
 }

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

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

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

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/supoort/GameResult.kt

@@ -0,0 +1,8 @@
+package blackjack.supoort
+
+import blackjack.participant.BettingAmount
+import blackjack.participant.Name
+
+data class GameResult(
+    val resultMap: Map<Name, BettingAmount>
+)