[블랙잭 1단계] 오이 미션 제출합니다.

README.md

@@ -1 +1,37 @@
-# kotlin-blackjack
+# kotlin-blackjack
+
+
+## 기능 구현 목록
+
+### 카드
+- [x] 숫자와 패턴을 가진 카드를 생성한다
+  - 패턴은 클로버/하트/다이아/스페이드
+
+<br>
+
+### 덱
+- [x] 고유한 52장의 카드를 가지고 있어야 한다
+- [x] 요청한 수량에 맞게 카드를 뽑을 수 있다
+
+<br>
+
+### 플레이어
+- [x] 이름과 패, 역할을 가지고 있다
+- [x] 덱에서 카드를 뽑아서 패에 가져온다
+- [x] 게임 상태를 가지고 있다
+  - `STAY`/`BUST`/`HIT`/`BLACKJACK`
+
+<br>
+
+### 패
+- [x] 패에 카드를 추가할 수 있다
+
+<br>
+
+### 점수 계산기
+- [x] 패에 들고 있는 카드의 합을 구할 수 있다
+
+<br>
+
+### 최종 승패
+- [x] 딜러의 점수와 각 플레이어의 점수를 비교하여 승패 여부를 판단한다

src/main/kotlin/blackjack/Application.kt

@@ -0,0 +1,7 @@
+package blackjack
+
+import blackjack.controller.BlackJackController
+
+fun main() {
+    BlackJackController().play()
+}

src/main/kotlin/blackjack/const/GameRule.kt

@@ -0,0 +1,12 @@
+package blackjack.const
+
+object GameRule {
+    const val FIRST_TURN_DRAW_AMOUNT = 2
+    const val HIT_DRAW_AMOUNT = 1
+
+    const val ACE_BASE_SCORE = 10
+    const val ACE_OTHER_SCORE = 11
+    const val BLACKJACK_SCORE = 21
+
+    const val DEALER_ADDITIONAL_DRAW_BASE_SCORE = 16
+}

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

@@ -0,0 +1,86 @@
+package blackjack.controller
+
+import blackjack.domain.GameResult
+import blackjack.domain.card.Deck
+import blackjack.domain.person.Dealer
+import blackjack.domain.person.Player
+import blackjack.uiModel.PersonUiModel
+import blackjack.uiModel.ResultUiModel
+import blackjack.view.InputView
+import blackjack.view.OutputView
+
+class BlackJackController(
+    private val inputView: InputView = InputView(),
+    private val outputView: OutputView = OutputView(),
+) {
+    private lateinit var deck: Deck
+
+    fun play() {
+        val players = generatePlayers()
+        val dealer = Dealer()
+        deck = Deck()
+
+        settingInitialCards(dealer, players)
+        processPlayerTurns(players)
+        processDealerTurns(dealer)
+
+        showGameResult(dealer, players)
+    }
+
+    private fun generatePlayers(): List<Player> {
+        outputView.printNameMessage()
+        return inputView.getNames().map { Player(it) }
+    }
+
+    private fun settingInitialCards(
+        dealer: Dealer,
+        players: List<Player>,
+    ) {
+        dealer.draw(deck)
+        players.forEach { person -> person.draw(deck) }
+        outputView.printDrawMessage(combinePerson(dealer, players))
+    }
+
+    private fun processPlayerTurns(players: List<Player>) {
+        players.forEach { player -> handlePlayerTurn(player) }
+    }
+
+    private fun handlePlayerTurn(player: Player) {
+        while (player.canDraw()) {
+            outputView.printFlagMessage(player.name)
+            letPlayerDrawCard(player)
+        }
+    }
+
+    private fun letPlayerDrawCard(player: Player) {
+        if (inputView.getFlag()) {
+            player.draw(deck)
+            outputView.printDrawStatus(PersonUiModel.create(player))
+            return
+        }
+        player.changeToStay()
+    }
+
+    private fun processDealerTurns(dealer: Dealer) {
+        while (dealer.canDraw()) {
+            outputView.printDealerDrawMessage()
+            dealer.draw(deck)
+        }
+    }
+
+    private fun showGameResult(
+        dealer: Dealer,
+        players: List<Player>,
+    ) {
+        outputView.printGameResult(combinePerson(dealer, players))
+        val gameResult = GameResult.create(dealer, players)
+        outputView.printResult(ResultUiModel.create(gameResult))
+    }
+
+    private fun combinePerson(
+        dealer: Dealer,
+        players: List<Player>,
+    ): List<PersonUiModel> {
+        return listOf(PersonUiModel.create(dealer)) + players.map(PersonUiModel::create)
+    }
+}

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

@@ -0,0 +1,20 @@
+package blackjack.domain
+
+import blackjack.domain.person.Dealer
+import blackjack.domain.person.Player
+import blackjack.domain.state.ResultState
+
+class GameResult private constructor(val winStatus: Map<Player, ResultState>) {
+    companion object {
+        fun create(
+            dealer: Dealer,
+            players: List<Player>,
+        ): GameResult {
+            return GameResult(
+                players.associateWith { player ->
+                    ResultState.calculateWin(player, dealer)
+                },
+            )
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+package blackjack.domain
+
+import blackjack.const.GameRule
+import blackjack.domain.card.Card
+import blackjack.domain.card.CardNumber
+
+class ScoreCalculator {
+    fun calculate(cards: List<Card>): Int {
+        val values = cards.map { getCardValue(it) }
+        val sum = values.sum()
+        return adjustAceValues(sum, values)
+    }
+
+    private fun getCardValue(card: Card): Int {
+        if (card.number == CardNumber.ACE) return GameRule.ACE_OTHER_SCORE
+        return card.number.value
+    }
+
+    private fun adjustAceValues(
+        sum: Int,
+        values: List<Int>,
+    ): Int {
+        var total = sum
+        val aceCount = values.count { it == GameRule.ACE_OTHER_SCORE }
+
+        repeat(aceCount) {
+            if (total > GameRule.BLACKJACK_SCORE) {
+                total -= GameRule.ACE_BASE_SCORE
+            }
+        }
+        return total
+    }
+}

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

@@ -0,0 +1,15 @@
+package blackjack.domain.card
+
+class Card private constructor(
+    val number: CardNumber,
+    val pattern: CardPattern,
+) {
+    companion object {
+        fun create(
+            number: CardNumber,
+            pattern: CardPattern,
+        ): Card {
+            return Card(number, pattern)
+        }
+    }
+}

src/main/kotlin/blackjack/domain/card/CardNumber.kt

@@ -0,0 +1,19 @@
+package blackjack.domain.card
+
+enum class CardNumber(val value: Int) {
+    ACE(1),
+
+    TWO(2),
+    THREE(3),
+    FOUR(4),
+    FIVE(5),
+    SIX(6),
+    SEVEN(7),
+    EIGHT(8),
+    NINE(9),
+    TEN(10),
+
+    JACK(10),
+    QUEEN(10),
+    KING(10),
+}

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

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

src/main/kotlin/blackjack/domain/card/Deck.kt

@@ -0,0 +1,28 @@
+package blackjack.domain.card
+
+class Deck {
+    private val _cards = mutableListOf<Card>()
+    val cards: List<Card> get() = _cards.toList()
+
+    init {
+        _cards.addAll(generateDeck())
+        require(cards.size == DECK_SIZE) { INVALID_DECK_SIZE_ERROR_MESSAGE }
+    }
+
+    fun draw(): Card {
+        require(cards.isNotEmpty()) { NO_SUCH_ELEMENT_ERROR_MESSAGE }
+        return _cards.removeFirst()
+    }
+
+    private fun generateDeck(): List<Card> = CardPattern.entries.flatMap(::createCard).shuffled()
+
+    private fun createCard(cardPattern: CardPattern): List<Card> {
+        return CardNumber.entries.map { cardNumber -> Card.create(cardNumber, cardPattern) }
+    }
+
+    companion object {
+        private const val DECK_SIZE = 52
+        private const val INVALID_DECK_SIZE_ERROR_MESSAGE = "덱은 52장의 카드로 구성되어야 합니다."
+        private const val NO_SUCH_ELEMENT_ERROR_MESSAGE = "남은 카드가 없습니다."
+    }
+}

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

@@ -0,0 +1,20 @@
+package blackjack.domain.person
+
+import blackjack.domain.card.Deck
+import blackjack.domain.state.DealerState
+
+class Dealer(hand: Hand) : Person(hand) {
+    init {
+        gameState = DealerState.FIRST_TURN
+    }
+
+    constructor() : this(hand = Hand())
+
+    override fun draw(deck: Deck) {
+        val amount = getDrawAmount(DealerState.FIRST_TURN)
+        repeat(amount) {
+            hand.addCard(deck.draw())
+        }
+        gameState = DealerState.from(this)
+    }
+}

src/main/kotlin/blackjack/domain/person/Hand.kt

@@ -0,0 +1,19 @@
+package blackjack.domain.person
+
+import blackjack.domain.card.Card
+
+class Hand {
+    private val _cards: MutableList<Card> = mutableListOf()
+
+    val cards: List<Card>
+        get() = _cards.toList()
+
+    fun addCard(card: Card) {
+        _cards.add(card)
+    }
+
+    fun copy(): Hand =
+        Hand().apply {
+            _cards.addAll(this@Hand._cards)
+        }
+}

src/main/kotlin/blackjack/domain/person/Person.kt

@@ -0,0 +1,30 @@
+package blackjack.domain.person
+
+import blackjack.const.GameRule
+import blackjack.domain.ScoreCalculator
+import blackjack.domain.card.Card
+import blackjack.domain.card.Deck
+import blackjack.domain.state.PersonState
+
+abstract class Person(
+    hand: Hand,
+    private val calculator: ScoreCalculator = ScoreCalculator(),
+) {
+    protected lateinit var gameState: PersonState
+    protected val hand = hand.copy()
+
+    abstract fun draw(deck: Deck)
+
+    fun cards(): List<Card> = hand.cards
+
+    fun canDraw(): Boolean = !gameState.isFinal
+
+    fun score(): Int = calculator.calculate(cards())
+
+    protected fun getDrawAmount(state: PersonState): Int {
+        if (gameState == state) {
+            return GameRule.FIRST_TURN_DRAW_AMOUNT
+        }
+        return GameRule.HIT_DRAW_AMOUNT
+    }
+}

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

@@ -0,0 +1,27 @@
+package blackjack.domain.person
+
+import blackjack.domain.card.Deck
+import blackjack.domain.state.PlayerState
+
+class Player(
+    val name: String,
+    hand: Hand,
+) : Person(hand) {
+    init {
+        gameState = PlayerState.FIRST_TURN
+    }
+
+    constructor(name: String) : this(name = name, hand = Hand())
+
+    override fun draw(deck: Deck) {
+        val amount = getDrawAmount(PlayerState.FIRST_TURN)
+        repeat(amount) {
+            hand.addCard(deck.draw())
+        }
+        gameState = PlayerState.from(this)
+    }
+
+    fun changeToStay() {
+        gameState = PlayerState.STAY
+    }
+}

src/main/kotlin/blackjack/domain/state/DealerState.kt

@@ -0,0 +1,20 @@
+package blackjack.domain.state
+
+import blackjack.const.GameRule
+import blackjack.domain.person.Dealer
+
+enum class DealerState(override val isFinal: Boolean) : PersonState {
+    FIRST_TURN(false),
+    HIT(false),
+    FINISH(true),
+    ;
+
+    companion object {
+        fun from(dealer: Dealer): DealerState =
+            when {
+                dealer.cards().size < GameRule.FIRST_TURN_DRAW_AMOUNT -> FIRST_TURN
+                dealer.score() > GameRule.DEALER_ADDITIONAL_DRAW_BASE_SCORE -> FINISH
+                else -> HIT
+            }
+    }
+}