Step3 블랙잭(딜러)

README.md

@@ -20,4 +20,21 @@
 - [x] 덱에서 카드를 하나 꺼낸다.
 - [x] 유저는 카드 목록을 보유한다.
 - [x] 카드목록에서 점수를 계산한다.
-- [x] 카드를 덱에서 하나 뽑는다.
+- [x] 카드를 덱에서 하나 뽑는다.
+
+## Step3 - 블랙잭(딜러)
+
+### Step2 - 리뷰반영사항
+- [x] BlackJackGame::game table 이 users 와 deck 을 상태로서 관리하도록 수정
+- [x] BlackJackGame::start 메서드 분리
+- [x] BlackJackGame::유저목록을 받아 card 출력하도록 수정
+- [x] BlackJackGame::카드 히트 여부확인시 출력과 입력을 통합
+- [x] BlackJackGame::while 문 내부 if 절을 while 조건식으로 통합
+- [x] BlackJackGame::게임진행책임 분리
+- [x] BlackJackGame::receive 를 hit 로 메서드명 수정
+- [x] Rank::enum 클래스로 수정
+
+### 기능 구현사항
+- [x] 딜러는 처음받는 2장의 합계가 16이하면 반드시 1장의 카드를 추가로 받는다
+- [x] 딜러가 21을 초과하면 남은 플레이어들은 패에 상관없이 승리한다
+- [x] 게임 완료 후 각 플레이어별로 승패를 출력한다

src/main/kotlin/blackjack/Main.kt

@@ -1,10 +1,9 @@
 package blackjack
 
-import blackjack.controller.BlackJackGame
-import blackjack.domain.GameTable
+import blackjack.controller.BlackjackGame
 import blackjack.view.InputView
 import blackjack.view.ResultView
 
 fun main() {
-    BlackJackGame(GameTable, InputView, ResultView).start()
+    BlackjackGame(InputView, ResultView).start()
 }

src/main/kotlin/blackjack/controller/BlackjackGame.kt

@@ -0,0 +1,87 @@
+package blackjack.controller
+
+import blackjack.domain.Dealer
+import blackjack.domain.Deck
+import blackjack.domain.GameResult
+import blackjack.domain.GameTable
+import blackjack.domain.Participant
+import blackjack.domain.Player
+import blackjack.view.InputView
+import blackjack.view.ResultView
+
+data class BlackjackGame(
+    private val inputView: InputView,
+    private val resultView: ResultView,
+) {
+    fun start() {
+        val gameTable = GameTable(Deck.create())
+        val participants = playGame(gameTable)
+        printCard(participants)
+        printGameResult(participants)
+    }
+
+    private fun playGame(gameTable: GameTable): List<Participant> {
+        val participants = setUpInitCard(gameTable)
+        val (players, dealer) = Participant.separate(participants)
+        val gamedPlayers = playersTurn(players, gameTable)
+        resultView.linebreak()
+        val gamedDealer = dealerTurn(dealer, gameTable)
+        return gamedPlayers + gamedDealer
+    }
+
+    private fun setUpInitCard(gameTable: GameTable): List<Participant> {
+        val participants = gameTable.dealInitCard(getParticipants())
+        resultView.linebreak()
+        resultView.printInitCardReceive(participants)
+        resultView.printParticipantsCard(participants = participants, printScore = false)
+        resultView.linebreak()
+        return participants
+    }
+
+    private fun getParticipants(): List<Participant> {
+        return buildList {
+            add(Dealer.create())
+            addAll(inputView.inputNames().map { Player.create(name = it) })
+        }
+    }
+
+    private fun playersTurn(
+        participants: List<Participant>,
+        gameTable: GameTable,
+    ): List<Participant> {
+        return participants.map { playerTurn(it, gameTable) }
+    }
+
+    private tailrec fun playerTurn(
+        player: Participant,
+        gameTable: GameTable,
+    ): Participant {
+        if (!player.canHit() || !inputView.inputHit(player)) {
+            return player
+        }
+        val hitPlayer = gameTable.hit(player)
+        resultView.printParticipantCard(participant = hitPlayer, printScore = false)
+        return playerTurn(hitPlayer, gameTable)
+    }
+
+    private tailrec fun dealerTurn(
+        dealer: Participant,
+        gameTable: GameTable,
+    ): Participant {
+        if (!dealer.canHit()) {
+            return dealer
+        }
+        resultView.printDealerHit()
+        return dealerTurn(gameTable.hit(dealer), gameTable)
+    }
+
+    private fun printCard(participants: List<Participant>) {
+        resultView.linebreak()
+        resultView.printParticipantsCard(participants = participants, printScore = true)
+    }
+
+    private fun printGameResult(participants: List<Participant>) {
+        resultView.linebreak()
+        resultView.printGameResult(GameResult.from(participants))
+    }
+}

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

@@ -1,19 +1,19 @@
 package blackjack.domain
 
-import blackjack.domain.Rank.Companion.ACE
+import blackjack.domain.Rank.ACE
 
 data class Card(
     val rank: Rank,
     val suit: Suit,
 ) {
-    val score = rank.score
+    val score: Int
+        get() = rank.score
 
-    fun isAce(): Boolean {
-        return rank == ACE
-    }
+    val isAce: Boolean
+        get() = rank == ACE
 
     companion object {
         val ALL: List<Card> =
-            Suit.entries.flatMap { suit -> Rank.ALL.map { rank -> Card(rank, suit) } }
+            Suit.entries.flatMap { suit -> Rank.entries.map { rank -> Card(rank, suit) } }
     }
 }

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

@@ -1,11 +1,26 @@
 package blackjack.domain
 
+import blackjack.domain.MatchResult.DRAW
+import blackjack.domain.MatchResult.LOSS
+import blackjack.domain.MatchResult.WIN
+
 data class Cards(val values: List<Card>) {
     val score: Int
         get() = calculateScore()
 
-    fun isScoreLowerThanLimit(): Boolean {
-        return score < BLACKJACK_SCORE_LIMIT
+    val isBust: Boolean
+        get() = calculateScore() > BLACKJACK_SCORE_LIMIT
+
+    fun scoreLowerThan(limit: Int): Boolean {
+        return score < limit
+    }
+
+    fun compareScore(other: Cards): MatchResult {
+        return when {
+            score > other.score -> WIN
+            score < other.score -> LOSS
+            else -> DRAW
+        }
     }
 
     fun add(card: Card): Cards {
@@ -14,7 +29,7 @@ data class Cards(val values: List<Card>) {
 
     private fun calculateScore(): Int {
         val totalScore = values.sumOf { it.score }
-        var aceCount = values.count { it.isAce() }
+        var aceCount = values.count { it.isAce }
 
         var adjustedScore = totalScore
         while (adjustedScore > BLACKJACK_SCORE_LIMIT && aceCount > 0) {

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

@@ -0,0 +1,27 @@
+package blackjack.domain
+
+import blackjack.domain.MatchResult.DRAW
+import blackjack.domain.MatchResult.LOSS
+import blackjack.domain.MatchResult.WIN
+import blackjack.domain.dto.DealerGameResult
+import blackjack.domain.dto.PlayerGameResult
+
+data class GameResult(
+    val dealerGameResult: DealerGameResult,
+    val playerGameResults: List<PlayerGameResult>,
+) {
+    companion object {
+        fun from(participants: List<Participant>): GameResult {
+            val (players, dealer) = Participant.separate(participants)
+            val playerGameResults = players.map { player -> PlayerGameResult(player, player.compareScore(dealer)) }
+            return GameResult(
+                DealerGameResult(
+                    winCount = playerGameResults.count { it.result == LOSS },
+                    lossCount = playerGameResults.count { it.result == WIN },
+                    drawCount = playerGameResults.count { it.result == DRAW },
+                ),
+                playerGameResults,
+            )
+        }
+    }
+}

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

@@ -1,16 +1,21 @@
 package blackjack.domain
 
-object GameTable {
-    const val INIT_CARD_DRAW_COUNT = 2
-
-    fun dealInitCard(
-        users: List<User>,
-        deck: Deck,
-    ): List<User> {
-        return users.map { user ->
-            (1..INIT_CARD_DRAW_COUNT).fold(user) { acc, _ ->
-                acc.receiveCard(deck.draw())
+data class GameTable(
+    private val deck: Deck,
+) {
+    fun dealInitCard(participants: List<Participant>): List<Participant> {
+        return participants.map { participant ->
+            (1..INIT_CARD_DRAW_COUNT).fold(participant) { acc, _ ->
+                acc.hit(deck.draw())
             }
         }
     }
+
+    fun hit(participant: Participant): Participant {
+        return participant.hit(deck.draw())
+    }
+
+    companion object {
+        const val INIT_CARD_DRAW_COUNT = 2
+    }
 }

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

@@ -0,0 +1,7 @@
+package blackjack.domain
+
+enum class MatchResult(val description: String) {
+    WIN("승"),
+    LOSS("패"),
+    DRAW("무"),
+}

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

@@ -0,0 +1,63 @@
+package blackjack.domain
+
+import blackjack.domain.MatchResult.LOSS
+import blackjack.domain.MatchResult.WIN
+
+sealed class Participant(val name: String, val cards: Cards) {
+    val isBust: Boolean
+        get() = cards.isBust
+
+    abstract fun canHit(): Boolean
+
+    abstract fun hit(card: Card): Participant
+
+    companion object {
+        fun separate(participants: List<Participant>): Pair<List<Player>, Dealer> {
+            return participants.filterIsInstance<Player>() to participants.first { it is Dealer } as Dealer
+        }
+    }
+}
+
+class Player(name: String, cards: Cards) : Participant(name, cards) {
+    override fun canHit(): Boolean {
+        return cards.scoreLowerThan(PLAYER_SCORE_LIMIT)
+    }
+
+    override fun hit(card: Card): Player {
+        return Player(this.name, cards.add(card))
+    }
+
+    fun compareScore(dealer: Dealer): MatchResult {
+        return when {
+            dealer.isBust -> WIN
+            this.isBust -> LOSS
+            else -> cards.compareScore(dealer.cards)
+        }
+    }
+
+    companion object {
+        private const val PLAYER_SCORE_LIMIT = 21
+
+        fun create(name: String): Player {
+            return Player(name, Cards(emptyList()))
+        }
+    }
+}
+
+class Dealer(cards: Cards) : Participant("딜러", cards) {
+    override fun canHit(): Boolean {
+        return cards.scoreLowerThan(DEALER_SCORE_LIMIT)
+    }
+
+    override fun hit(card: Card): Dealer {
+        return Dealer(cards.add(card))
+    }
+
+    companion object {
+        private const val DEALER_SCORE_LIMIT = 17
+
+        fun create(): Dealer {
+            return Dealer(Cards(emptyList()))
+        }
+    }
+}