Step3: 블랙잭(딜러)

Readme.md

@@ -2,14 +2,22 @@
 
 ## 플레이어
   * 플레이어는 이름을 가지고 있다
+  * 블랙잭 시작 시 각 플레이어는 카드 2장을 받는다
+  * 발급 받은 카드를 항상 공개한다
+  * 21이 넘지 않을 때 까지 카드를 받을 수 있다
+
+## 딜러
+  * 처음 받은 2장이 16이하면 17이상이 될 때까지 카드를 받는다
+  * 발급 받은 카드 중 한장만 공개한다
+  * 마지막에 카드를 모두 공개한다
+
+## 블랙잭 딜러 승패 계산
+  * 딜러가 21이 넘으면 플레이어는 모두 승리한다
+  * 딜러가 21이 넘지 않으면 21에 가까운 플레이어가 승리한다
 
 ## 블랙잭 카드
   * 숫자(1 ~ 10, Jack, Queen, King)와 문양(클로버, 스페이드, 하트, 다이아)으로 구성
 
 ## 블랙잭 카드 계산
   * Ace는 1 또는 11로 계산한다
   * King, Queen, Jack은 각각 10으로 계산한다
-
-## 블랙잭 드로우 룰
-  * 블랙잭 시작 시 각 플레이어는 카드 2장을 받는다
-  * 21이 넘지 않을 때 까지 카드를 받을 수 있다

src/main/kotlin/blackjack/Main.kt

@@ -1,26 +1,55 @@
 package blackjack
 
+import blackjack.domain.Dealer
 import blackjack.domain.ShuffledCardDeck
 import blackjack.domain.Player
 import blackjack.view.InputView
 import blackjack.view.OutputView
 
 fun main() {
+    val cardDeck = ShuffledCardDeck()
+    val (dealer, players) = createParticipants(cardDeck)
+    obtainCards(players, dealer)
+    compareBetweenDealerAndPlayers(dealer, players)
+}
+
+private fun createParticipants(cardDeck: ShuffledCardDeck): Pair<Dealer, List<Player>> {
+    val dealer = Dealer(cardDeck)
+    val players = createPlayers(cardDeck)
+    OutputView.printParticipantOpenedCards(listOf(dealer) + players)
+    return Pair(dealer, players)
+}
+
+private fun createPlayers(cardDeck: ShuffledCardDeck): List<Player> {
     val names = InputView.inputNames()
-    val players = names.map { Player(it, ShuffledCardDeck()) }
+    return names.map { Player(it, cardDeck) }
+}
 
-    OutputView.printPlayersCards(players)
-    players.forEach { obtainCard(it) }
-    OutputView.printPlayerResult(players)
+private fun obtainCards(players: List<Player>, dealer: Dealer) {
+    players.forEach { obtainPlayerCard(it) }
+    obtainDealerCard(dealer)
 }
 
-private fun obtainCard(player: Player) {
-    while (isObtainCard(player)) {
+private fun obtainPlayerCard(player: Player) {
+    while (isPlayerObtainCard(player)) {
         player.obtain()
-        OutputView.printPlayerCards(player)
+        OutputView.printParticipantCards(player.name, player.hands)
     }
 }
 
-private fun isObtainCard(player: Player): Boolean {
+private fun isPlayerObtainCard(player: Player): Boolean {
     return player.isObtainable() && InputView.inputIsObtainCard(player.name)
 }
+
+private fun obtainDealerCard(dealer: Dealer) {
+    while(dealer.isObtainable()) {
+        dealer.obtain()
+        OutputView.printObtainDealerCard()
+    }
+}
+
+private fun compareBetweenDealerAndPlayers(dealer: Dealer, players: List<Player>) {
+    val compareResults = dealer.compareWith(*players.toTypedArray())
+    OutputView.printParticipantHands(listOf(dealer) + players)
+    OutputView.printCompareResults(compareResults)
+}

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

@@ -1,5 +1,7 @@
 package blackjack.domain
 
+const val BLACKJACK_SCORE = 21
+
 class Cards (
     cards: List<Card>,
 ) {
@@ -10,7 +12,7 @@ class Cards (
     constructor(vararg cards: Card): this(cards.toList())
 
     fun sum(): Int {
-        if (BLACKJACK < sumOfMaximum()) {
+        if (BLACKJACK_SCORE < sumOfMaximum()) {
             return sumOfMinimum()
         }
         return sumOfMaximum()
@@ -32,12 +34,4 @@ class Cards (
     fun add(card: Card) {
         cards.add(card)
     }
-
-    fun isLessThanBlackjack(): Boolean {
-        return sum() < BLACKJACK
-    }
-
-    companion object {
-        private const val BLACKJACK = 21
-    }
 }

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

@@ -0,0 +1,9 @@
+package blackjack.domain
+
+enum class CompareResult {
+    DEALER_LOSE,
+    DRAW,
+    DEALER_WIN
+    ;
+
+}

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

@@ -0,0 +1,35 @@
+package blackjack.domain
+
+class Dealer(
+    cardDeck: CardDeck
+): Participant("딜러", cardDeck) {
+    override val openedCards = listOf(hands.first())
+
+    override fun isObtainable(): Boolean {
+        return sumOfCards() < 17
+    }
+
+    fun compareWith(vararg players: Player): Map<String, CompareResult> {
+        return players.associate { it.name to compareWith(it) }
+    }
+
+    private fun compareWith(player: Player): CompareResult {
+        if (isMoreThanBlackjack()) {
+            return CompareResult.DEALER_LOSE
+        }
+        if (player.isMoreThanBlackjack()) {
+            return CompareResult.DEALER_WIN
+        }
+        return compareBySumOfCards(player)
+    }
+
+    private fun compareBySumOfCards(player: Player): CompareResult {
+        if (sumOfCards() == player.sumOfCards()) {
+            return CompareResult.DRAW
+        }
+        if (sumOfCards() < player.sumOfCards()) {
+            return CompareResult.DEALER_LOSE
+        }
+        return CompareResult.DEALER_WIN
+    }
+}

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

@@ -0,0 +1,27 @@
+package blackjack.domain
+
+abstract class Participant(
+    val name: String,
+    private val cardDeck: CardDeck,
+) {
+    private val cards = Cards(cardDeck.next(), cardDeck.next())
+    abstract val openedCards: List<Card>
+
+    val hands
+        get() = cards.values
+
+    fun obtain() {
+        require(isObtainable()) { "카드를 획득할 수 없습니다." }
+        cards.add(cardDeck.next())
+    }
+
+    fun sumOfCards(): Int {
+        return cards.sum()
+    }
+
+    fun isMoreThanBlackjack(): Boolean {
+        return sumOfCards() > BLACKJACK_SCORE
+    }
+
+    abstract fun isObtainable(): Boolean
+}

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

@@ -1,23 +1,12 @@
 package blackjack.domain
 
-class Player(
-    val name: String,
-    private val cardDeck: CardDeck,
-) {
-    private val cards = Cards(cardDeck.next(), cardDeck.next())
-    val hands
-        get() = cards.values
-
-    fun obtain() {
-        require(isObtainable()) { "카드를 획득할 수 없습니다." }
-        cards.add(cardDeck.next())
-    }
-
-    fun sumOfCards(): Int {
-        return cards.sum()
-    }
-
-    fun isObtainable(): Boolean {
-        return cards.isLessThanBlackjack()
+class Player (
+    name: String,
+    cardDeck: CardDeck,
+) : Participant(name, cardDeck) {
+    override val openedCards = hands.subList(0, 2)
+
+    override fun isObtainable(): Boolean {
+        return sumOfCards() < BLACKJACK_SCORE
     }
 }

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

@@ -11,8 +11,7 @@ class ShuffledCardDeck: CardDeck {
     }
 
     private fun deck(): Iterator<Card> {
-        return (0 until 4)
-            .flatMap { cards() }
+        return cards()
             .shuffled()
             .iterator()
     }

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

@@ -1,21 +1,23 @@
 package blackjack.view
 
 import blackjack.domain.Card
+import blackjack.domain.CompareResult
 import blackjack.domain.Number
-import blackjack.domain.Player
+import blackjack.domain.Participant
 import blackjack.domain.Shape
 
 object OutputView {
-
-    fun printPlayersCards(players: List<Player>) {
+    fun printParticipantOpenedCards(players: List<Participant>) {
         val names = players.joinToString(separator = ", ") { it.name }
         println("${names}에게 2장의 카드를 나누었습니다")
-        players.forEach { printPlayerCards(it) }
+        players.forEach {
+            printParticipantCards(it.name, it.openedCards)
+        }
     }
 
-    fun printPlayerCards(player: Player) {
-        val hands = player.hands.joinToString(", ") { cardText(it) }
-        println("${player.name} 카드 : $hands")
+    fun printParticipantCards(name: String, cards: List<Card>) {
+        val cardsText = cards.joinToString(", ") { cardText(it) }
+        println("${name} 카드 : $cardsText")
     }
 
     private fun cardText(card: Card): String {
@@ -41,10 +43,41 @@ object OutputView {
         }
     }
 
-    fun printPlayerResult(players: List<Player>) {
-        for (player in players) {
-            val hands = player.hands.joinToString(", ") { cardText(it) }
-            println("${player.name} 카드 : $hands - 결과: ${player.sumOfCards()}")
+    fun printObtainDealerCard() {
+        println("딜러는 16이하라 한장의 카드를 더 받았습니다.")
+    }
+
+    fun printParticipantHands(participants: List<Participant>) {
+        for (participant in participants) {
+            val hands = participant.hands.joinToString(", ") { cardText(it) }
+            println("${participant.name} 카드 : $hands - 결과: ${participant.sumOfCards()}")
+        }
+    }
+
+    fun printCompareResults(compareResults: Map<String, CompareResult>) {
+        println("## 최종 승패")
+        printDealerResult(compareResults)
+        printPlayerResult(compareResults)
+    }
+
+    private fun printDealerResult(compareResults: Map<String, CompareResult>) {
+        val dealerWinCount = compareResults.values.count { it == CompareResult.DEALER_WIN }
+        val dealerDrawCount = compareResults.values.count { it == CompareResult.DRAW }
+        val dealerLoseCount = compareResults.values.count { it == CompareResult.DEALER_LOSE }
+        println("딜러 : ${dealerWinCount}승 ${dealerDrawCount}무 ${dealerLoseCount}패")
+    }
+
+    private fun printPlayerResult(compareResults: Map<String, CompareResult>) {
+        compareResults.forEach { (name, result) ->
+            println("${name} ${playerResultText(result)}")
+        }
+    }
+
+    private fun playerResultText(result: CompareResult): String {
+        return when(result) {
+            CompareResult.DEALER_LOSE -> "승"
+            CompareResult.DRAW -> "무"
+            CompareResult.DEALER_WIN -> "패"
         }
     }
 }