Step3: 블랙잭(딜러)

README.md

@@ -21,3 +21,18 @@
 
 * 카드의 숫자 계산은 카드 숫자를 기본으로 하며, 예외로 Ace는 1 또는 11로 계산할 수 있으며, King, Queen, Jack은 각각 10으로 계산한다.
 * 게임을 시작하면 플레이어는 두 장의 카드를 지급 받으며, 두 장의 카드 숫자를 합쳐 21을 초과하지 않으면서 21에 가깝게 만들면 이긴다. 21을 넘지 않을 경우 원한다면 얼마든지 카드를 계속 뽑을 수 있다.
+
+## step3 - 딜러
+
+### TO DO
+
+- [X] 게임 시작 시 딜러에게 카드 2장 지급, 1장 오픈
+- [X] 게임 진행 시 딜러 카드 합계가 16 이하이면 1장 추가로 받기
+- [X] 딜러 21 초과하면 플레이어 승리
+- [X] 플레이어 별 승패 출력
+
+### 기능 요구 사항
+
+* 딜러는 처음에 받은 2장의 합계가 16이하이면 반드시 1장의 카드를 추가로 받아야 하고, 17점 이상이면 추가로 받을 수 없다.
+* 딜러가 21을 초과하면 그 시점까지 남아 있던 플레이어들은 가지고 있는 패에 상관 없이 승리한다.
+* 게임을 완료한 후 각 플레이어별로 승패를 출력한다.

src/main/kotlin/controller/BlackJackController.kt

@@ -1,24 +1,41 @@
 package controller
 
-import domain.Game
-import domain.Player
+import domain.dealer.Dealer
+import domain.player.Player
+import domain.player.Players
+import domain.turn.Game
+import domain.turn.InitialTurn
 import presentation.InputView
 import presentation.ResultView
 
 fun main() {
-    val game = Game(
-        InputView.getPlayerNames()
-            .map { Player(it) }
-    )
-    game.start()
-    ResultView.printInitialState(game.players)
+    val playerNames = InputView.getPlayerNames()
+    val players = Players(playerNames.map { Player(it) })
+    val dealer = Dealer()
+
+    val game = Game(InitialTurn, dealer, players)
+    game.proceed()
+    ResultView.printInitialState(dealer, players.list)
+    dealer.addOnHitCallback {
+        ResultView.printDealerReceiveCardMessage()
+    }
 
     while (true) {
-        val playerReceiveMoreCard = Players(game.playersCanReceiveMoreCard())
-        if (playerReceiveMoreCard.noMorePlayer()) break
+        game.playersCanTakeNextTurn().list.filterNot {
+            InputView.askReceiveCard(it.name)
+        }.forEach {
+            it.stay()
+        }
+
+        game.proceed()
 
-        playerReceiveMoreCard.hit(game)
+        if (game.isFinish) {
+            game.result?.let {
+                ResultView.printResult(it)
+            }
+            break
+        }
 
-        ResultView.printResult(game.players)
+        ResultView.printResult(dealer, players.list)
     }
 }

src/main/kotlin/domain/Result.kt

@@ -0,0 +1,11 @@
+package domain
+
+import domain.player.Players
+
+data class Result(
+    val winners: Players,
+    val losers: Players,
+) {
+    val numOfWinner = winners.list.size
+    val numOfLoser = losers.list.size
+}

src/main/kotlin/domain/card/Cards.kt

@@ -23,11 +23,9 @@ class Cards(cards: List<Card> = emptyList()) {
             sumWithoutAce + it
         }
 
-        if (sumOfAllCases.contains(BLACKJACK_POINT)) {
-            return BLACKJACK_POINT
-        }
-
-        return sumOfAllCases.min()
+        return sumOfAllCases.filter {
+            it <= BLACKJACK_POINT
+        }.maxOrNull() ?: sumOfAllCases.min()
     }
 
     private fun doesNotHaveAce(): Boolean {

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

@@ -0,0 +1,41 @@
+package domain.dealer
+
+import domain.card.CardDeck
+import domain.card.Cards
+
+class Dealer(initialState: DealerState = DealerState.Hit(Cards())) {
+
+    private var state: DealerState = initialState
+    private var onHit: (() -> Unit)? = null
+
+    val cards: Cards
+        get() = state.cards
+
+    val canReceiveMoreCard: Boolean
+        get() = state.canReceiveMoreCard
+
+    val isBlackJack: Boolean
+        get() = state is DealerState.BlackJack
+
+    val isBust: Boolean
+        get() = state is DealerState.Bust
+
+    val result: Int
+        get() = state.cards.result()
+
+    fun hit(cardDeck: CardDeck) {
+        val capturedState = state
+        if (capturedState is DealerState.Hit) {
+            state = capturedState.hit(cardDeck.pop())
+            onHit?.invoke()
+        }
+    }
+
+    fun addOnHitCallback(callback: (() -> Unit)) {
+        onHit = callback
+    }
+
+    companion object {
+        const val DEALER_MAX_POINT = 16
+    }
+}

src/main/kotlin/domain/dealer/DealerState.kt

@@ -0,0 +1,41 @@
+package domain.dealer
+
+import domain.card.Card
+import domain.card.Cards
+
+sealed interface DealerState {
+    val cards: Cards
+
+    val canReceiveMoreCard: Boolean
+
+    class Hit(override val cards: Cards) : DealerState {
+        fun hit(card: Card): DealerState {
+            cards.add(card)
+            return DealerState(cards)
+        }
+
+        override val canReceiveMoreCard: Boolean = cards.result() <= Dealer.DEALER_MAX_POINT
+    }
+
+    class Bust(override val cards: Cards) : DealerState {
+        override val canReceiveMoreCard: Boolean = false
+    }
+
+    class Stay(override val cards: Cards) : DealerState {
+        override val canReceiveMoreCard: Boolean = false
+    }
+
+    class BlackJack(override val cards: Cards) : DealerState {
+        override val canReceiveMoreCard: Boolean = false
+    }
+}
+
+fun DealerState(cards: Cards): DealerState {
+    val result = cards.result()
+    return when {
+        result > Cards.BLACKJACK_POINT -> DealerState.Bust(cards)
+        result == Cards.BLACKJACK_POINT -> DealerState.BlackJack(cards)
+        result > Dealer.DEALER_MAX_POINT -> DealerState.Stay(cards)
+        else -> DealerState.Hit(cards)
+    }
+}

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

@@ -0,0 +1,35 @@
+package domain.player
+
+import domain.card.Card
+import domain.card.Cards
+
+open class Player(val name: String, initialState: PlayerState = PlayerState.Hit(Cards())) {
+
+    private var state: PlayerState = initialState
+
+    val cards: Cards
+        get() = state.cards
+
+    val result: Int
+        get() = state.cards.result()
+
+    val isBust: Boolean
+        get() = state is PlayerState.Bust
+
+    val isHit: Boolean
+        get() = state is PlayerState.Hit
+
+    open val canReceiveMoreCard: Boolean
+        get() = state.canReceiveMoreCard
+
+    fun hit(card: Card) {
+        val capturedState = state
+        if (capturedState is PlayerState.Hit) {
+            state = capturedState.hit(card)
+        }
+    }
+
+    fun stay() {
+        state = PlayerState.Stay(state.cards)
+    }
+}

src/main/kotlin/domain/player/PlayerState.kt

@@ -0,0 +1,40 @@
+package domain.player
+
+import domain.card.Card
+import domain.card.Cards
+
+sealed interface PlayerState {
+    val cards: Cards
+
+    val canReceiveMoreCard: Boolean
+
+    class Hit(override val cards: Cards) : PlayerState {
+        fun hit(card: Card): PlayerState {
+            cards.add(card)
+            return PlayerState(cards)
+        }
+
+        override val canReceiveMoreCard: Boolean = true
+    }
+
+    class Bust(override val cards: Cards) : PlayerState {
+        override val canReceiveMoreCard: Boolean = false
+    }
+
+    class Stay(override val cards: Cards) : PlayerState {
+        override val canReceiveMoreCard: Boolean = false
+    }
+
+    class BlackJack(override val cards: Cards) : PlayerState {
+        override val canReceiveMoreCard: Boolean = false
+    }
+}
+
+fun PlayerState(cards: Cards): PlayerState {
+    val result = cards.result()
+    return when {
+        result == Cards.BLACKJACK_POINT -> PlayerState.BlackJack(cards)
+        result < Cards.BLACKJACK_POINT -> PlayerState.Hit(cards)
+        else -> PlayerState.Bust(cards)
+    }
+}

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

@@ -0,0 +1,24 @@
+package domain.player
+
+import domain.card.CardDeck
+
+data class Players(val list: List<Player>) {
+
+    fun hit(cardDeck: CardDeck) {
+        list.forEach {
+            it.hit(cardDeck.pop())
+        }
+    }
+
+    fun playersCanReceiveMoreCard(): Players {
+        return Players(
+            list.filter {
+                it.canReceiveMoreCard
+            }
+        )
+    }
+
+    fun noMoreHit(): Boolean {
+        return list.none { it.isHit }
+    }
+}