[Step2] 🚀 2단계 - 블랙잭

README.md

@@ -1 +1,33 @@
-# kotlin-blackjack
+# kotlin-blackjack
+
+---
+
+# 블랙잭
+
+## 요구 사항 분석
+
+- 입력
+  - [x] 게임에 참여할 사람을 입력받는다.
+  - [x] 한장의 카드를 더 받을지 말지 입력받는다.
+
+- 출력
+  - [x] 플레이어가 가지고 있는 카드를 출력한다.
+  - [x] 게임의 결과를 출력한다.
+
+- 도메인
+  - [x] 카드가 있다.
+    - [x] 카드는 숫자와 무늬를 가진다.
+    - [x] Ace, King, Queen, Jack 이라는 카드도 있다.
+  - [x] 카드 덱이 있다.
+    - [x] 카드 덱은 총 51장의 카드를 가진다.
+  - [x] 플레이어가 있다.
+    - [x] 플레이어는 이름을 가진다.
+    - [x] 플레이어는 카드를 가질 수 있다.
+  - [x] 블랙잭 게임이 있다.
+    - [x] 게임 시작시 두 장의 카드를 지급받는다.
+    - [x] 플레이어는 가지고 있는 카드가 21을 넘지 않은 경우 카드를 계속 뽑을 수 있다.
+  - [x] 블랙잭 점수 계산기가 있다.
+    - [x] Ace는 1 또는 11로 계산할 수 있다.
+    - [x] King, Queen, Jack 는 10으로 계산한다
+    - [x] 플레이어의 카드를 점수로 계산해 결과를 내보낸다
+

src/main/kotlin/blackjack/GameManager.kt

@@ -0,0 +1,62 @@
+package blackjack
+
+import blackjack.card.CardDeck
+import blackjack.ui.InputManager
+import blackjack.ui.OutputManager
+
+class GameManager(
+    private val inputManager: InputManager,
+    private val outputManager: OutputManager
+) {
+    private val players: List<Player>
+
+    init {
+        players = joinPlayers()
+    }
+
+    fun start() {
+        players.forEach { it.drawCard(CardDeck.draw(FIRST_DRAW)) }
+
+        outputManager.printFirstTurn(players)
+        outputManager.printPlayersCards(players)
+
+        playBlackJack()
+
+        players.forEach {
+            outputManager.printPlayerResultGame(it)
+        }
+    }
+
+    private fun playBlackJack() {
+        players.forEach {
+            playerDraw(it)
+        }
+    }
+
+    private fun playerDraw(player: Player) {
+        var drawAmount = -1
+
+        while (player.shouldDraw() && drawAmount != 0) {
+            drawAmount = inputManager.inputShouldDrawCard(player.name)
+            if (playerChooseDraw(drawAmount)) {
+                player.drawCard(CardDeck.draw(drawAmount))
+            }
+            outputManager.printPlayerCards(player)
+        }
+    }
+
+    private fun playerChooseDraw(drawAmount: Int) = drawAmount > 0
+
+    private fun joinPlayers(): List<Player> {
+        val playerNames: List<String> = inputManager.inputPlayerNames()
+        return playerNames.map { Player(it, ScoreCalculator()) }
+    }
+
+    companion object {
+        private const val FIRST_DRAW: Int = 2
+    }
+}
+
+fun main() {
+    GameManager(InputManager(), OutputManager()).start()
+}

src/main/kotlin/blackjack/Player.kt

@@ -0,0 +1,22 @@
+package blackjack
+
+import blackjack.card.BlackJackCard
+
+class Player(
+    val name: String,
+    private val scoreCalculator: ScoreCalculator
+) {
+    val cards: MutableList<BlackJackCard> = mutableListOf()
+
+    fun drawCard(cards: List<BlackJackCard>) {
+        this.cards.addAll(cards)
+    }
+
+    fun shouldDraw(): Boolean {
+        return resultScore() <= 21
+    }
+
+    fun resultScore(): Int {
+        return scoreCalculator.calcScore(cards)
+    }
+}

src/main/kotlin/blackjack/ScoreCalculator.kt

@@ -0,0 +1,47 @@
+package blackjack
+
+import blackjack.card.AceCard
+import blackjack.card.BlackJackCard
+import blackjack.card.NormalCard
+import blackjack.card.PictureCard
+import kotlin.math.abs
+
+class ScoreCalculator {
+    fun calcScore(card: List<BlackJackCard>): Int {
+        return card.filterIsInstance<AceCard>().fold(calcScoreToNormalAndPictureCard(card)) { acc, _ ->
+            calcAceScore(acc)
+        }
+    }
+
+    private fun calcAceScore(score: Int): Int {
+        var totalScore = score
+        val plusMinAceScore = totalScore + MIN_ACE_SCORE
+        val plusMaxAcreScore = totalScore + MAX_ACE_SCORE
+
+        totalScore += when {
+            (isMinAceScoreCloser(plusMaxAcreScore, plusMinAceScore)) -> MIN_ACE_SCORE
+            else -> MAX_ACE_SCORE
+        }
+
+        return totalScore
+    }
+
+    private fun isMinAceScoreCloser(plusMaxAcreScore: Int, plusMinAceScore: Int): Boolean {
+        return abs(plusMinAceScore - BEST_SCORE) < abs(plusMaxAcreScore - BEST_SCORE)
+    }
+
+    private fun calcScoreToNormalAndPictureCard(card: List<BlackJackCard>) = card.sumOf {
+        when (it) {
+            is NormalCard -> it.number
+            is PictureCard -> PICTURE_CARD_SCORE
+            else -> 0
+        }
+    }
+
+    companion object {
+        private const val PICTURE_CARD_SCORE: Int = 10
+        private const val BEST_SCORE: Int = 21
+        private const val MIN_ACE_SCORE: Int = 1
+        private const val MAX_ACE_SCORE: Int = 11
+    }
+}

src/main/kotlin/blackjack/card/AceCard.kt

@@ -0,0 +1,3 @@
+package blackjack.card
+
+class AceCard(val pattern: CardPattern) : BlackJackCard

src/main/kotlin/blackjack/card/BlackJackCard.kt

@@ -0,0 +1,3 @@
+package blackjack.card
+
+sealed interface BlackJackCard

src/main/kotlin/blackjack/card/CardDeck.kt

@@ -0,0 +1,45 @@
+package blackjack.card
+
+object CardDeck {
+    private val deck: ArrayDeque<BlackJackCard>
+    private const val EMPTY_DECK_ERROR_MESSAGE: String = "카드 덱이 모두 소진되었습니다."
+    private const val FIRST_NORMAL_CARD_NUMBER: Int = 2
+    private const val LAST_NORMAL_CARD_NUMBER: Int = 10
+
+    init {
+        val list = mutableListOf<BlackJackCard>()
+        initNormalCard(list)
+        initPictureCard(list)
+        initAceCard(list)
+
+        list.shuffle()
+        deck = ArrayDeque(list)
+    }
+
+    fun getSize(): Int {
+        return deck.size
+    }
+
+    fun draw(drawNumber: Int): List<BlackJackCard> {
+        require(deck.size >= drawNumber) { EMPTY_DECK_ERROR_MESSAGE }
+        return (1..drawNumber).map { deck.removeFirst() }.toList()
+    }
+
+    private fun initNormalCard(list: MutableList<BlackJackCard>) {
+        CardPattern.values().forEach {
+            (FIRST_NORMAL_CARD_NUMBER..LAST_NORMAL_CARD_NUMBER).forEach { number -> list.add(NormalCard(number, it)) }
+        }
+    }
+
+    private fun initPictureCard(list: MutableList<BlackJackCard>) {
+        CardPattern.values().forEach {
+            CardPicture.values().forEach { picture -> list.add(PictureCard(picture, it)) }
+        }
+    }
+
+    private fun initAceCard(list: MutableList<BlackJackCard>) {
+        CardPattern.values().forEach {
+            list.add(AceCard(it))
+        }
+    }
+}

src/main/kotlin/blackjack/card/CardPattern.kt

@@ -0,0 +1,8 @@
+package blackjack.card
+
+enum class CardPattern {
+    DIAMOND,
+    CLOVER,
+    SPADE,
+    HEART;
+}

src/main/kotlin/blackjack/card/CardPicture.kt

@@ -0,0 +1,7 @@
+package blackjack.card
+
+enum class CardPicture {
+    KING,
+    JACK,
+    QUEEN;
+}

src/main/kotlin/blackjack/card/NormalCard.kt

@@ -0,0 +1,3 @@
+package blackjack.card
+
+class NormalCard(val number: Int, val pattern: CardPattern) : BlackJackCard

src/main/kotlin/blackjack/card/PictureCard.kt

@@ -0,0 +1,6 @@
+package blackjack.card
+
+class PictureCard(
+    val picture: CardPicture,
+    val pattern: CardPattern
+) : BlackJackCard

src/main/kotlin/blackjack/ui/InputManager.kt

@@ -0,0 +1,29 @@
+package blackjack.ui
+
+class InputManager {
+    fun inputPlayerNames(): List<String> {
+        println(INPUT_PLAYER_NAMES_MESSAGE)
+        return inputUserValue().replace("\\s".toRegex(), "").split(",")
+    }
+
+    private fun inputUserValue(): String {
+        val input = readln()
+        require(input.isNotBlank()) { INPUT_NOT_NULL_MESSAGE }
+        return input.trim()
+    }
+
+    fun inputShouldDrawCard(name: String): Int {
+        println("${name}는 $INPUT_SHOULD_DRAW_CARD_MESSAGE")
+        return when (readln()) {
+            "Y", "y" -> 1
+            "N", "n" -> 0
+            else -> 0
+        }
+    }
+
+    companion object {
+        private const val INPUT_NOT_NULL_MESSAGE = "입력값을 입력해주세요."
+        private const val INPUT_PLAYER_NAMES_MESSAGE: String = "게임에 참여할 사람의 이름을 입력하세요.(쉼표 기준으로 분리)"
+        private const val INPUT_SHOULD_DRAW_CARD_MESSAGE: String = "한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)"
+    }
+}

src/main/kotlin/blackjack/ui/OutputManager.kt

@@ -0,0 +1,61 @@
+package blackjack.ui
+
+import blackjack.Player
+import blackjack.card.AceCard
+import blackjack.card.BlackJackCard
+import blackjack.card.CardPattern
+import blackjack.card.CardPicture
+import blackjack.card.NormalCard
+import blackjack.card.PictureCard
+
+class OutputManager {
+
+    fun printFirstTurn(players: List<Player>) {
+        val names: String = players.joinToString(", ") { it.name }
+
+        println("${names}에게 두장의 카드를 나누었습니다.")
+    }
+
+    fun printPlayersCards(players: List<Player>) {
+        players.forEach {
+            println("${it.name}: ${parsingCardsToString(it.cards)}")
+        }
+    }
+
+    fun printPlayerCards(player: Player) {
+        println("${player.name}: ${parsingCardsToString(player.cards)}")
+    }
+
+    fun printPlayerResultGame(player: Player) {
+        println("${player.name} 카드: ${parsingCardsToString(player.cards)} - 결과: ${player.resultScore()}")
+    }
+
+    private fun parsingCardsToString(cards: List<BlackJackCard>): String {
+        return cards.joinToString(", ") { parsingCardToString(it) }
+    }
+
+    private fun parsingCardToString(card: BlackJackCard): String {
+        return when (card) {
+            is NormalCard -> "${card.number}${parsingCardPatternToString(card.pattern)}"
+            is PictureCard -> "${parsingCardPictureToString(card.picture)}${parsingCardPatternToString(card.pattern)}"
+            is AceCard -> "ace${parsingCardPatternToString(card.pattern)}"
+        }
+    }
+
+    private fun parsingCardPatternToString(cardPattern: CardPattern): String {
+        return when (cardPattern) {
+            CardPattern.DIAMOND -> "다이아"
+            CardPattern.CLOVER -> "클로버"
+            CardPattern.SPADE -> "스페이드"
+            CardPattern.HEART -> "하트"
+        }
+    }
+
+    private fun parsingCardPictureToString(cardPicture: CardPicture): String {
+        return when (cardPicture) {
+            CardPicture.KING -> "K"
+            CardPicture.JACK -> "J"
+            CardPicture.QUEEN -> "Q"
+        }
+    }
+}

src/main/kotlin/Languages.kt → src/main/kotlin/dsl/Languages.kt

@@ -1,3 +1,5 @@
+package dsl
+
 class Languages {
     private val languageMap: HashMap<String, Int> = hashMapOf()
     infix fun String.level(level: Int): Unit = putLanguage(this, level)

src/main/kotlin/Person.kt → src/main/kotlin/dsl/Person.kt

@@ -1,3 +1,5 @@
+package dsl
+
 data class Person(
     val name: String,
     val company: String?,

src/main/kotlin/PersonBuilder.kt → src/main/kotlin/dsl/PersonBuilder.kt

@@ -1,3 +1,5 @@
+package dsl
+
 fun introduce(block: PersonBuilder.() -> Unit): Person {
 //    val personBuilder = PersonBuilder()
 //    personBuilder.block()

src/main/kotlin/Skill.kt → src/main/kotlin/dsl/Skill.kt

@@ -1,3 +1,5 @@
+package dsl
+
 class Skill {
     private val hardSkills: MutableList<String> = mutableListOf()
     private val softSkills: MutableList<String> = mutableListOf()