feat: 게임 완료 후 각 플레이어별로 승패를 출력한다

Author: DuhanMo

README.md

@@ -37,4 +37,4 @@
 ### 기능 구현사항
 - [x] 딜러는 처음받는 2장의 합계가 16이하면 반드시 1장의 카드를 추가로 받는다
 - [x] 딜러가 21을 초과하면 남은 플레이어들은 패에 상관없이 승리한다
-- [ ] 게임 완료 후 각 플레이어별로 승패를 출력한다
+- [x] 게임 완료 후 각 플레이어별로 승패를 출력한다

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

@@ -2,19 +2,21 @@ 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
 
-class BlackjackGame(
+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)
     }
 
@@ -36,6 +38,13 @@ class BlackjackGame(
         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,
@@ -51,7 +60,7 @@ class BlackjackGame(
             return player
         }
         val hitPlayer = gameTable.hit(player)
-        resultView.printParticipantCard(participant = player, printScore = false)
+        resultView.printParticipantCard(participant = hitPlayer, printScore = false)
         return playerTurn(hitPlayer, gameTable)
     }
 
@@ -66,15 +75,13 @@ class BlackjackGame(
         return dealerTurn(gameTable.hit(dealer), gameTable)
     }
 
-    private fun printGameResult(participants: List<Participant>) {
+    private fun printCard(participants: List<Participant>) {
         resultView.linebreak()
         resultView.printParticipantsCard(participants = participants, printScore = true)
     }
 
-    private fun getParticipants(): List<Participant> {
-        return buildList {
-            add(Dealer.create())
-            addAll(inputView.inputNames().map { Player.create(name = it) })
-        }
+    private fun printGameResult(participants: List<Participant>) {
+        resultView.linebreak()
+        resultView.printGameResult(GameResult.from(participants))
     }
 }

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,6 +1,6 @@
 package blackjack.domain
 
-class GameTable(
+data class GameTable(
     private val deck: Deck,
 ) {
     fun dealInitCard(participants: List<Participant>): List<Participant> {

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

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

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

@@ -1,8 +1,12 @@
 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
@@ -24,10 +28,11 @@ class Player(name: String, cards: Cards) : Participant(name, cards) {
     }
 
     fun compareScore(dealer: Dealer): MatchResult {
-        if (dealer.isBust) {
-            return WIN
+        return when {
+            dealer.isBust -> WIN
+            this.isBust -> LOSS
+            else -> cards.compareScore(dealer.cards)
         }
-        return cards.compareScore(dealer.cards)
     }
 
     companion object {
@@ -40,9 +45,6 @@ class Player(name: String, cards: Cards) : Participant(name, cards) {
 }
 
 class Dealer(cards: Cards) : Participant("딜러", cards) {
-    val isBust: Boolean
-        get() = cards.isBust
-
     override fun canHit(): Boolean {
         return cards.scoreLowerThan(DEALER_SCORE_LIMIT)
     }

src/main/kotlin/blackjack/domain/dto/DealerGameResult.kt

@@ -0,0 +1,7 @@
+package blackjack.domain.dto
+
+data class DealerGameResult(
+    val winCount: Int,
+    val lossCount: Int,
+    val drawCount: Int,
+)

src/main/kotlin/blackjack/domain/dto/PlayerGameResult.kt

@@ -0,0 +1,9 @@
+package blackjack.domain.dto
+
+import blackjack.domain.MatchResult
+import blackjack.domain.Player
+
+data class PlayerGameResult(
+    val player: Player,
+    val result: MatchResult,
+)

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

@@ -1,5 +1,6 @@
 package blackjack.view
 
+import blackjack.domain.GameResult
 import blackjack.domain.GameTable.Companion.INIT_CARD_DRAW_COUNT
 import blackjack.domain.Participant
 
@@ -31,6 +32,20 @@ object ResultView {
         println("딜러는 16이하라 한장의 카드를 더 받았습니다.")
     }
 
+    fun printGameResult(gameResult: GameResult) {
+        val winMessage =
+            if (gameResult.dealerGameResult.winCount > 0) "${gameResult.dealerGameResult.winCount}승" else ""
+        val lossMessage =
+            if (gameResult.dealerGameResult.lossCount > 0) "${gameResult.dealerGameResult.lossCount}패" else ""
+        val drawMessage =
+            if (gameResult.dealerGameResult.drawCount > 0) "${gameResult.dealerGameResult.drawCount}무" else ""
+        println("## 최종 승패")
+        println("딜러: $winMessage $lossMessage $drawMessage")
+        gameResult.playerGameResults.forEach {
+            println("${it.player.name} ${it.result.description}")
+        }
+    }
+
     fun linebreak() {
         println()
     }