[블랙잭 1단계] 미플 미션 제출합니다

README.md

@@ -1 +1,26 @@
-# kotlin-blackjack
+# 블랙잭
+
+## 기능 목록
+
+- [x] 카드 Shape에는 스페이드, 다이아몬드, 하트, 클로버가 있다.
+- [x] 카드 Number에는 1~10, J, Q, K가 있다.
+- [x] 카드는 Number와 Shape의 조합을 가진다.
+
+- 덱
+    - [x] 덱은 카드 리스트를 생성한다.
+    - [x] 덱에서 카드 한 장을 꺼낼 수 있다.
+    - [x] 덱에 카드가 존재하지 않은 경우 예외가 발생한다.
+
+- 입력
+    - [x] 사용자 이름을 입력받는다.
+        - [x] 사용자 이름이 중복될 경우 재입력 받는다.
+    -[x] 플레이어에게 한 장 더 받을지 입력받는다.
+        - [x] 입력값이 y, n이 아니면 재입력 받는다.
+
+- 출력
+    - [x] 플레이어 이름과 함께 초기 카드 안내 메시지를 출력한다.
+    - [x] 딜러와 플레이어 초기 카드 상태를 출력한다.
+    - [x] 각 플레이어마다 현재 카드 상태를 출력한다.
+    - [x] 딜러의 카드 점수에 따라 안내 문구를 출력한다.
+    - [x] 딜러와 모든 플레이어의 최종 카드 상태와 점수를 출력한다.
+    - [x] 최종 승패를 출력한다.

src/main/kotlin/blackjack/BlackjackGame.kt

@@ -0,0 +1,11 @@
+package blackjack
+
+import blackjack.controller.BlackjackController
+import blackjack.model.Dealer
+import blackjack.view.InputView
+import blackjack.view.OutputView
+
+fun main() {
+    val blackjackController = BlackjackController(InputView(), OutputView())
+    blackjackController.play(dealer = Dealer())
+}

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

@@ -0,0 +1,75 @@
+package blackjack.controller
+
+import blackjack.model.Dealer
+import blackjack.model.Deck.INITIAL_HAND_OUT_CARD_COUNT
+import blackjack.model.DrawChoice
+import blackjack.model.GameManager
+import blackjack.model.Player
+import blackjack.view.InputView
+import blackjack.view.OutputView
+
+class BlackjackController(
+    private val inputView: InputView,
+    private val outputView: OutputView,
+) {
+    private lateinit var gameManager: GameManager
+
+    fun play(dealer: Dealer) {
+        val players = playerSetting()
+
+        outputView.printInitialHandOutCardMessage(players)
+        gameManager = GameManager(dealer, players)
+        gameManager.dealInitialCardWithCount(INITIAL_HAND_OUT_CARD_COUNT)
+        outputView.printAllPlayerHands(dealer, players)
+
+        playersDrawCards(players)
+
+        dealerDrawCards(dealer)
+
+        outputView.printFinalHandStatus(dealer, players)
+
+        resultSummary(gameManager)
+    }
+
+    private fun playerSetting(): List<Player> {
+        var playerNames: List<String>? = null
+        while (playerNames == null) {
+            playerNames = inputView.readPlayerNames()
+        }
+        return playerNames.map { Player(it) }
+    }
+
+    private fun playersDrawCards(players: List<Player>) {
+        players.forEach { player -> playerDrawOrStay(player) }
+    }
+
+    private fun playerDrawOrStay(player: Player) {
+        var condition: String? = null
+        while (condition == null) {
+            condition = inputView.readMoreCardCondition(player)
+        }
+        val playerCondition = DrawChoice.from(condition)
+        if (playerCondition!!.isStay()) {
+            outputView.printPlayerHands(player)
+            return
+        }
+        gameManager.drawCard(player)
+        outputView.printPlayerHands(player)
+        if (player.isBust()) return
+        playerDrawOrStay(player)
+    }
+
+    private fun dealerDrawCards(dealer: Dealer) {
+        val moreCard = dealer.isMoreCard()
+        if (moreCard) {
+            gameManager.drawCard(dealer)
+        }
+        outputView.printDealerHandStatus(moreCard)
+    }
+
+    private fun resultSummary(gameManager: GameManager) {
+        val result = gameManager.calculateResultMap()
+        val dealerResult = gameManager.calculateDealerResult(result)
+        outputView.printFinalResult(result, dealerResult)
+    }
+}

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

@@ -0,0 +1,3 @@
+package blackjack.model
+
+data class Card(val shape: Shape, val number: Number)

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

@@ -0,0 +1,16 @@
+package blackjack.model
+
+import blackjack.model.ResultType.Companion.BUST_NUMBER
+
+class Dealer : Person() {
+    val name = DEALER_NAME
+
+    fun isMoreCard() = calculateTotalScore() < DEALER_MORE_CARD_MINIMUM
+
+    override fun isBust(): Boolean = super.calculateTotalScore() > BUST_NUMBER
+
+    companion object {
+        private const val DEALER_NAME = "딜러"
+        private const val DEALER_MORE_CARD_MINIMUM = 17
+    }
+}

src/main/kotlin/blackjack/model/Deck.kt

@@ -0,0 +1,22 @@
+package blackjack.model
+
+object Deck {
+    const val INITIAL_HAND_OUT_CARD_COUNT = 2
+    private const val ERROR_NO_MORE_CARD_MESSAGE = "카드가 더 없습니다."
+    private val CARDS = generateCards()
+
+    fun draw(): Card {
+        return CARDS.removeFirstOrNull() ?: throw IllegalStateException(ERROR_NO_MORE_CARD_MESSAGE)
+    }
+
+    fun drawWithCount(count: Int): List<Card> {
+        return List(count) { draw() }
+    }
+
+    private fun generateCards(): MutableList<Card> =
+        Shape.entries.flatMap { shape ->
+            Number.entries.map { number ->
+                Card(shape, number)
+            }
+        }.shuffled().toMutableList()
+}

src/main/kotlin/blackjack/model/DrawChoice.kt

@@ -0,0 +1,17 @@
+package blackjack.model
+
+enum class DrawChoice(val answer: String) {
+    YES("y"),
+    NO("n"),
+    ;
+
+    fun isStay(): Boolean {
+        return this == NO
+    }
+
+    companion object {
+        fun from(answer: String): DrawChoice? {
+            return entries.find { choice -> choice.answer == answer }
+        }
+    }
+}

src/main/kotlin/blackjack/model/GameManager.kt

@@ -0,0 +1,38 @@
+package blackjack.model
+
+class GameManager(
+    private val dealer: Dealer,
+    private val players: List<Player>,
+) {
+    fun dealInitialCardWithCount(count: Int) {
+        dealer.addCards(Deck.drawWithCount(count))
+        players.forEach { player -> player.addCards(Deck.drawWithCount(count)) }
+    }
+
+    fun calculateResultMap(): Map<Player, ResultType> {
+        val playersStatus =
+            players.associateBy(
+                { player -> player },
+                { player -> ResultType.judgeScore(dealer, player) },
+            )
+        return playersStatus
+    }
+
+    fun calculateDealerResult(resultMap: Map<Player, ResultType>): Map<ResultType, Int> {
+        val result = mutableMapOf<ResultType, Int>()
+
+        resultMap.forEach {
+            when (it.value) {
+                ResultType.WIN -> result[ResultType.LOSS] = result.getOrDefault(ResultType.LOSS, 0) + 1
+                ResultType.TIE -> result[ResultType.TIE] = result.getOrDefault(ResultType.TIE, 0) + 1
+                ResultType.LOSS -> result[ResultType.WIN] = result.getOrDefault(ResultType.WIN, 0) + 1
+            }
+        }
+
+        return result
+    }
+
+    fun drawCard(person: Person) {
+        person.addCard(Deck.draw())
+    }
+}

src/main/kotlin/blackjack/model/Number.kt

@@ -0,0 +1,28 @@
+package blackjack.model
+
+enum class Number(val score: Int) {
+    ACE(11),
+    TWO(2),
+    THREE(3),
+    FOUR(4),
+    FIVE(5),
+    SIX(6),
+    SEVEN(7),
+    EIGHT(8),
+    NINE(9),
+    TEN(10),
+    JACK(10),
+    QUEEN(10),
+    KING(10),
+    ;
+
+    override fun toString(): String {
+        return when (this) {
+            ACE -> "A"
+            JACK -> "J"
+            QUEEN -> "Q"
+            KING -> "K"
+            else -> (ordinal + 1).toString()
+        }
+    }
+}

src/main/kotlin/blackjack/model/Person.kt

@@ -0,0 +1,14 @@
+package blackjack.model
+
+abstract class Person {
+    private val _cards: MutableList<Card> = mutableListOf()
+    open val cards get() = _cards.toList()
+
+    fun addCard(card: Card) = _cards.add(card)
+
+    fun addCards(cards: List<Card>) = _cards.addAll(cards)
+
+    fun calculateTotalScore() = cards.sumOf { card -> card.number.score }
+
+    abstract fun isBust(): Boolean
+}

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

@@ -0,0 +1,26 @@
+package blackjack.model
+
+import blackjack.model.ResultType.Companion.BUST_NUMBER
+
+class Player(
+    val name: String,
+) : Person() {
+    fun adjustScore(): Int {
+        var sumScore = calculateTotalScore()
+        var countAce = countAce()
+        while (countAce-- > 0) {
+            if (sumScore > BUST_NUMBER) {
+                sumScore -= ADJUST_ACE_NUMBER
+            }
+        }
+        return sumScore
+    }
+
+    private fun countAce() = super.cards.count { it.number == Number.ACE }
+
+    override fun isBust() = adjustScore() > BUST_NUMBER
+
+    companion object {
+        private const val ADJUST_ACE_NUMBER = 10
+    }
+}

src/main/kotlin/blackjack/model/ResultType.kt

@@ -0,0 +1,22 @@
+package blackjack.model
+
+enum class ResultType(val value: Char) {
+    WIN('승'),
+    TIE('무'),
+    LOSS('패'), ;
+
+    companion object {
+        fun judgeScore(
+            dealer: Dealer,
+            player: Player,
+        ): ResultType {
+            val dealerFinalScore = if (dealer.isBust()) 0 else dealer.calculateTotalScore()
+            val playerFinalScore = if (player.isBust()) 0 else player.calculateTotalScore()
+            if (dealerFinalScore < playerFinalScore) return WIN
+            if (dealerFinalScore == playerFinalScore) return TIE
+            return LOSS
+        }
+
+        const val BUST_NUMBER = 21
+    }
+}

src/main/kotlin/blackjack/model/Shape.kt

@@ -0,0 +1,8 @@
+package blackjack.model
+
+enum class Shape(val type: String) {
+    SPADE("스페이드"),
+    DIAMOND("다이아몬드"),
+    HEART("하트"),
+    CLOVER("클로버"),
+}

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

@@ -0,0 +1,43 @@
+package blackjack.view
+
+import blackjack.model.DrawChoice
+import blackjack.model.Player
+
+class InputView {
+    fun readPlayerNames(): List<String>? {
+        println(PLAYER_NAME_MESSAGE_GUIDE)
+        val playerNames: List<String> = readln().split(PLAYER_NAME_DELIMITER).map { name -> name.trim() }
+
+        if (playerNames.any { it.isEmpty() }) {
+            println(ERROR_PLAYER_NAME_EMPTY)
+            return null
+        }
+
+        if (playerNames.size != playerNames.toSet().size) {
+            println(ERROR_INVALID_PLAYER_NAMES)
+            return null
+        }
+
+        return playerNames
+    }
+
+    fun readMoreCardCondition(player: Player): String? {
+        println(PLAYER_MORE_CARD_MESSAGE_GUIDE.format(player.name))
+        val condition: String = readln().trim()
+        if (DrawChoice.from(condition) == null) {
+            println(ERROR_INVALID_CARD_CONDITION)
+            return null
+        }
+
+        return condition
+    }
+
+    companion object {
+        private const val PLAYER_NAME_MESSAGE_GUIDE = "게임에 참여할 사람의 이름을 입력하세요.(쉼표 기준으로 분리)"
+        private const val ERROR_PLAYER_NAME_EMPTY = "플레이어 이름은 비어있으면 안 됩니다. 다시 입력해주세요."
+        private const val ERROR_INVALID_PLAYER_NAMES = "중복된 이름이 있습니다. 다시 입력해주세요."
+        private const val PLAYER_MORE_CARD_MESSAGE_GUIDE = "%s은(는) 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)"
+        private const val ERROR_INVALID_CARD_CONDITION = "y나 n을 입력해야 합니다. 다시 입력해주세요."
+        private const val PLAYER_NAME_DELIMITER = ","
+    }
+}