🚀 4단계 - 블랙잭(베팅)

src/main/kotlin/blackjack/BlackjackApplication.kt

@@ -3,7 +3,7 @@ package blackjack
 import blackjack.domain.BlackjackResults
 import blackjack.domain.BlackjackShoe
 import blackjack.domain.Dealer
-import blackjack.domain.Participant
+import blackjack.domain.Participants
 import blackjack.view.InputView
 import blackjack.view.OutputView
 
@@ -15,29 +15,25 @@ class BlackjackApplication(
     fun run() {
         val blackjackShoe = BlackjackShoe()
         val (dealer, participantList) = ready(blackjackShoe)
-        play(dealer = dealer, participantList = participantList, blackjackShoe = blackjackShoe)
-        finish(dealer = dealer, participantList = participantList)
+        play(dealer = dealer, participants = participantList, blackjackShoe = blackjackShoe)
+        finish(dealer = dealer, participants = participantList)
     }
 
-    private fun ready(blackjackShoe: BlackjackShoe): Pair<Dealer, List<Participant>> {
-        val participantNames = inputView.getParticipantNames()
+    private fun ready(blackjackShoe: BlackjackShoe): Pair<Dealer, Participants> {
+        val participantNames: List<String> = inputView.getParticipantNames()
+        val participants = Participants(participantNames = participantNames.toTypedArray())
+        inputView.requestBettingMoney(participants)
 
         val dealer = Dealer()
-        val participants = participantNames.map { name -> Participant(name.trim()) }
-
-        dealer.receiveCard(blackjackShoe.draw())
-        participants.forEach { participant ->
-            repeat(2) {
-                participant.receiveCard(blackjackShoe.draw())
-            }
-        }
+        dealer.setupCard(blackjackShoe = blackjackShoe)
+        participants.setupCard(blackjackShoe = blackjackShoe)
 
         outputView.showReady(dealer = dealer, participants = participants)
         return dealer to participants
     }
 
-    private fun play(dealer: Dealer, participantList: List<Participant>, blackjackShoe: BlackjackShoe) {
-        participantList.forEach { participant ->
+    private fun play(dealer: Dealer, participants: Participants, blackjackShoe: BlackjackShoe) {
+        participants.forEach { participant ->
             while (participant.canReceiveCard && inputView.getMoreCard(participant)) {
                 val card = blackjackShoe.draw()
                 participant.receiveCard(card)
@@ -52,10 +48,10 @@ class BlackjackApplication(
         }
     }
 
-    private fun finish(dealer: Dealer, participantList: List<Participant>) {
+    private fun finish(dealer: Dealer, participants: Participants) {
         outputView.showDealerInfo(dealer = dealer)
-        outputView.showParticipantsInfo(participantList)
-        outputView.showResult(BlackjackResults(dealer = dealer, participants = participantList))
+        outputView.showParticipantsInfo(participants)
+        outputView.showResult(BlackjackResults(dealer = dealer, participants = participants))
     }
 
 }

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

@@ -5,22 +5,21 @@ class BlackjackResults(
     val participants: List<Participant>,
 ) {
 
-    val result: Map<BlackjackResult, List<Participant>> = run {
+    val result: List<Player> = run {
         val dealerScore = dealer.score
-        participants.groupBy { participant ->
-            val participantScore = participant.score
 
-            when {
-                participantScore > dealerScore -> BlackjackResult.WIN
-                participantScore < dealerScore -> BlackjackResult.LOSE
-                else -> BlackjackResult.DRAW
+        participants.forEach { participant ->
+            val participantScore = participant.score
+            val bettingMoney = when {
+                (participantScore <= Const.NUMBER_BLACKJACK && participantScore > dealerScore) || dealerScore > Const.NUMBER_BLACKJACK -> participant.bettingMoney
+                (dealerScore <= Const.NUMBER_BLACKJACK && participantScore < dealerScore) || participantScore > Const.NUMBER_BLACKJACK -> -participant.bettingMoney
+                else -> 0
             }
+
+            dealer.money -= bettingMoney
+            participant.money += bettingMoney
         }
-    }
 
-    enum class BlackjackResult {
-        WIN,
-        LOSE,
-        DRAW,
+        listOf(dealer, *participants.toTypedArray())
     }
 }

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

@@ -0,0 +1,5 @@
+package blackjack.domain
+
+object Const {
+    const val NUMBER_BLACKJACK = 21
+}

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

@@ -7,6 +7,10 @@ data class Dealer(
     override val canReceiveCard: Boolean
         get() = score <= CAN_RECEIVE_CARD_SCORE
 
+    override fun setupCard(blackjackShoe: BlackjackShoe) {
+        receiveCard(blackjackShoe.draw())
+    }
+
     companion object {
         private const val DEFAULT_DEALER_NAME = "딜러"
         private const val CAN_RECEIVE_CARD_SCORE = 16

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

@@ -3,12 +3,21 @@ package blackjack.domain
 data class Participant(
     override val name: String
 ) : Player(name = name) {
+    var bettingMoney: Int = 0
+
     override val canReceiveCard: Boolean
         get() {
             return score <= CAN_RECEIVE_CARD_SCORE
         }
 
+    override fun setupCard(blackjackShoe: BlackjackShoe) {
+        repeat(NUMBER_OF_INIT_CARD) {
+            receiveCard(blackjackShoe.draw())
+        }
+    }
+
     companion object {
         private const val CAN_RECEIVE_CARD_SCORE = 21
+        private const val NUMBER_OF_INIT_CARD = 2
     }
 }

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

@@ -0,0 +1,10 @@
+package blackjack.domain
+
+class Participants(private val participants: List<Participant>): List<Participant> by participants {
+
+    constructor(vararg participantNames: String): this(participantNames.map { name -> Participant(name.trim()) })
+
+    fun setupCard(blackjackShoe: BlackjackShoe) {
+        participants.forEach { participant -> participant.setupCard(blackjackShoe) }
+    }
+}

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

@@ -19,6 +19,10 @@ abstract class Player(
             return score
         }
 
+    var money: Int = 0
+
+    abstract fun setupCard(blackjackShoe: BlackjackShoe)
+
     fun receiveCard(card: Card) {
         _cardList.add(card)
     }

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

@@ -1,6 +1,7 @@
 package blackjack.view
 
 import blackjack.domain.Participant
+import blackjack.domain.Participants
 
 class InputView {
 
@@ -19,4 +20,13 @@ class InputView {
         }
     }
 
+    fun requestBettingMoney(participants: Participants) {
+        println()
+        participants.forEach { participant ->
+            println("${participant.name}의 배팅 금액은?")
+            val bettingMoney = readlnOrNull()?.toIntOrNull() ?: error("배팅은 ")
+            participant.bettingMoney = bettingMoney
+        }
+    }
+
 }

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

@@ -4,9 +4,10 @@ import blackjack.domain.BlackjackResults
 import blackjack.domain.Card
 import blackjack.domain.Dealer
 import blackjack.domain.Participant
+import blackjack.domain.Participants
 
 class OutputView {
-    fun showReady(dealer: Dealer, participants: List<Participant>) {
+    fun showReady(dealer: Dealer, participants: Participants) {
         println("\n${dealer.name}와 ${participants.joinToString { it.name }}에게 2장의 나누었습니다.")
 
         showDealerCard(dealer)
@@ -39,20 +40,9 @@ class OutputView {
     }
 
     fun showResult(blackjackResults: BlackjackResults) {
-        println("\n## 최종승패")
-        val result = blackjackResults.result
-        val participantWin = result[BlackjackResults.BlackjackResult.WIN].orEmpty()
-        val participantLose = result[BlackjackResults.BlackjackResult.LOSE].orEmpty()
-        val participantDraw = result[BlackjackResults.BlackjackResult.DRAW].orEmpty()
-        println("${blackjackResults.dealer.name}: ${participantLose.size}승 ${participantWin.size}패 ${participantDraw.size}무")
-        participantWin.forEach {
-            println("${it.name}: 승")
-        }
-        participantLose.forEach {
-            println("${it.name}: 패")
-        }
-        participantDraw.forEach {
-            println("${it.name}: 무")
+        println("\n## 최종 수익")
+        blackjackResults.result.forEach { player ->
+            println("${player.name}: ${player.money}")
         }
     }
 

src/test/kotlin/blackjack/BlackjackResultsTest.kt

@@ -22,13 +22,14 @@ class BlackjackResultsTest {
                 Participant("a").apply {
                     receiveCard(Card(Suit.SPADE, Rank.KING))
                     receiveCard(Card(Suit.SPADE, Rank.NINE))
+                    bettingMoney = 10000
                 }
             )
         )
 
-        val actual = blackjackResults.result[BlackjackResults.BlackjackResult.LOSE]?.size
+        val actual = blackjackResults.result.first().money
         actual.shouldNotBeNull()
-        actual shouldBe 1
+        actual shouldBe 10000
     }
 
     @Test
@@ -42,13 +43,14 @@ class BlackjackResultsTest {
                 Participant("a").apply {
                     receiveCard(Card(Suit.SPADE, Rank.KING))
                     receiveCard(Card(Suit.SPADE, Rank.KING))
+                    bettingMoney = 10000
                 }
             )
         )
 
-        val actual = blackjackResults.result[BlackjackResults.BlackjackResult.WIN]?.size
+        val actual = blackjackResults.result.first().money
         actual.shouldNotBeNull()
-        actual shouldBe 1
+        actual shouldBe -10000
     }
 
     @Test
@@ -62,12 +64,57 @@ class BlackjackResultsTest {
                 Participant("a").apply {
                     receiveCard(Card(Suit.SPADE, Rank.KING))
                     receiveCard(Card(Suit.SPADE, Rank.KING))
+                    bettingMoney = 10000
                 }
             )
         )
 
-        val actual = blackjackResults.result[BlackjackResults.BlackjackResult.DRAW]?.size
+        val actual = blackjackResults.result.first().money
         actual.shouldNotBeNull()
-        actual shouldBe 1
+        actual shouldBe 0
+    }
+
+    @Test
+    fun `딜러가 버스트면 참가자의 승`() {
+        val blackjackResults = BlackjackResults(
+            Dealer().apply {
+                receiveCard(Card(Suit.SPADE, Rank.KING))
+                receiveCard(Card(Suit.SPADE, Rank.KING))
+                receiveCard(Card(Suit.SPADE, Rank.KING))
+            },
+            listOf(
+                Participant("a").apply {
+                    receiveCard(Card(Suit.SPADE, Rank.KING))
+                    receiveCard(Card(Suit.SPADE, Rank.KING))
+                    bettingMoney = 10000
+                },
+            )
+        )
+
+        val actual = blackjackResults.result.first().money
+        actual.shouldNotBeNull()
+        actual shouldBe -10000
+    }
+
+    @Test
+    fun `참가자가 버스트면 딜러가 승`() {
+        val blackjackResults = BlackjackResults(
+            Dealer().apply {
+                receiveCard(Card(Suit.SPADE, Rank.KING))
+                receiveCard(Card(Suit.SPADE, Rank.KING))
+            },
+            listOf(
+                Participant("a").apply {
+                    receiveCard(Card(Suit.SPADE, Rank.KING))
+                    receiveCard(Card(Suit.SPADE, Rank.KING))
+                    receiveCard(Card(Suit.SPADE, Rank.KING))
+                    bettingMoney = 10000
+                },
+            )
+        )
+
+        val actual = blackjackResults.result.first().money
+        actual.shouldNotBeNull()
+        actual shouldBe 10000
     }
 }