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

README.md

@@ -1 +1,63 @@
-# kotlin-blackjack
+# kotlin-blackjack
+
+- 카드들 상태
+    - [X] 게임 진행 중 카드들의 상태는 Blackjack, Bust, None이 있다.
+    - [X] 카드들의 점수와 처음 턴 여부를 받아서 카드들의 상태를 반환한다.
+      - Blackjack는 처음 받은 카드의 합이 21이다.
+      - Bust는 카드의 합이 21초과이다.
+      - None은 카드의 합이 21미만이다.
+- 게임 결과
+    - [X] 게임 결과는 Push, Win, Lose가 있고, 한국어 게임 결과를 가진다.
+    - [X] Push는 기준 점수가 비교 점수와 같다.
+    - [X] Win는 기준 점수가 비교 점수보다 높다.
+    - [X] Lose는 기준 점수가 비교 점수보다 낮다.
+- 플레이어
+    - [X] 플레이어는 이름과 카드 리스트를 가진다.
+    - [X] 플레이어는 카드를 추가로 받을 수 있다.
+    - [X] 플레이어가 이름만 가질 경우, 가진 카드 리스트는 비어있다.
+    - 플레이어 이름 검증 로직
+        - [X] 플레이어의 이름은 1자 이상 5자 이내이다.
+        - [X] 플레이어 이름은 공백일 수 없다.
+        - [X] 플레이어 이름은 딜러가 될 수 없다.
+        - [X] 플레이어 이름은 중복될 수 없다.
+- 카드 모양
+    - [X] 카드 모양은 클로버, 하트, 다이아몬드, 스페이드를 가진다.
+    - [X] 각 모양에 대해 한글 이름을 가진다.
+- 카드
+    - [X] Card는 모양과 denomination(끗수)를 가진다.
+    - [X] Card의 끗수가 J, Q, K이면 숫자는 10이다.
+    - [X] Card의 끗수가 2~10 사이의 숫자이면 숫자 그대로 가진다.
+    - [X] 위의 끗수가 아닐 경우엔 숫자는 0이다.
+- 카드들
+    - [X] 카드들은 생성자로 카드 리스트를 가진다.
+    - [X] Ace 카드가 0개 일때, 카드들의 총합을 반환한다.
+    - [X] Ace 카드가 1개이고 카드의 합이 11미만 일때, Ace카드를 11로 판단한다.
+    - [X] Ace 카드가 1개이고 카드의 합이 11이상 일때, Ace카드를 1로 판단한다.
+    - [X] Ace 카드가 2개이고 카드의 합이 10미만 일때, Ace카드의 합을 12로 판단한다.
+        - Ace의 카드 2장 중 1장은 11, 1장은 1로 판단한다.
+    - [X] Ace 카드가 2개이고 카드의 합이 10이상 일때, Ace카드의 합을 2로 판단한다.
+        - Ace의 카드 2장 다 1로 판단한다.
+    - [X] Ace 카드가 3개이고 카드의 합이 9미만 일때, Ace카드의 합을 13로 판단한다.
+        - Ace의 카드 3장 중 1장은 11, 2장은 1로 판단한다.
+    - [X] Ace 카드가 3개이고 카드의 합이 9이상 일때, Ace카드의 합을 3으로 판단한다.
+        - Ace의 카드 3장 다 1로 판단한다.
+    - [X] Ace 카드가 4개이고 카드의 합이 8미만 일때, Ace카드의 합을 14로 판단한다.
+        - Ace의 카드 4장 중 1장은 11, 3장은 1로 판단한다.
+    - [X] Ace 카드가 4개이고 카드의 합이 8이상 일때, Ace카드를 합을 4으로 판단한다.
+        - Ace의 카드 4장 다 1로 판단한다.
+    - [X] 카드들에 카드를 추가할 수 있다.
+- 플레이어 행동
+    - [X] 응답은 Y, N로만 받을 수 있다.
+    - [X] 플레이 행동은 hit과 stay로 나뉜다.
+    - [X] 딜러 카드의 합이 16 이하일 경우 hit을 반환하고, 아닐 경우엔 stay를 반환한다.
+- 딜러
+    - [X] 딜러는 이름과 카드들을 가진다.
+    - [X] 딜러는 이름이 없을 경우, 딜러라는 이름을 가진다.
+    - [X] 딜러의 초기 카드 리스트는 비어있다.
+    - [X] 딜러는 카드를 추가로 받을 수 있다.
+- 카드 생성기
+    - [X] 무작위로 섞은 카드 번들을 생성한다.
+- 카드 덱
+    - [X] 카드 덱은 첫번째 순서의 카드부터 차례대로 카드를 반환한다.
+- 끗수
+    - [X] 끗수는 제목과 숫자를 가진다.

src/main/kotlin/blackjack/Application.kt

@@ -0,0 +1,10 @@
+package blackjack
+
+import blackjack.controller.BlackjackController
+import blackjack.view.InputView
+import blackjack.view.OutputView
+
+fun main() {
+    val blackjackController = BlackjackController(InputView(), OutputView())
+    blackjackController.run()
+}

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

@@ -0,0 +1,170 @@
+package blackjack.controller
+
+import blackjack.model.CardDeck
+import blackjack.model.CardsMaker
+import blackjack.model.CardsStatus
+import blackjack.model.Dealer
+import blackjack.model.GameResult
+import blackjack.model.Player
+import blackjack.model.PlayerBehavior
+import blackjack.model.Players
+import blackjack.view.InputView
+import blackjack.view.OutputView
+
+class BlackjackController(
+    private val inputView: InputView,
+    private val outputView: OutputView,
+) {
+    private val cardDeck = CardDeck(CardsMaker.CARDS)
+
+    fun run() {
+        outputView.printStartMessage()
+        val players: Players = inputView.readPlayers()
+        val dealer = Dealer()
+
+        getCards(players, dealer)
+        playGames(players, dealer)
+    }
+
+    private fun getCards(
+        players: Players,
+        dealer: Dealer,
+    ) {
+        repeat(2) {
+            getCardsToPlayer(players.value)
+            getCardsToDealer(dealer)
+        }
+        outputView.printPlayersCards(dealer, players.value)
+    }
+
+    private fun getCardsToPlayer(players: List<Player>) {
+        players.forEach { player ->
+            val card = cardDeck.pickCard()
+            player.appendCard(card)
+        }
+    }
+
+    private fun getCardsToDealer(dealer: Dealer) {
+        val card = cardDeck.pickCard()
+        dealer.appendCard(card)
+    }
+
+    private fun playGames(
+        players: Players,
+        dealer: Dealer,
+    ) {
+        if (dealer.isBlackjack(true)) {
+            val blackjackPlayers: List<Player> = players.findBlackjackPlayer()
+            updateGameResult(players, dealer)
+            outputView.printDealerBlackjackMessage(dealer, blackjackPlayers)
+            displayResult(players, dealer)
+            return
+        }
+        players.value.forEach { player ->
+            playGame(player, dealer)
+        }
+        displayResult(players, dealer)
+    }
+
+    private fun updateGameResult(
+        players: Players,
+        dealer: Dealer,
+    ) {
+        players.value.forEach { player ->
+            if (isAllPlayerBlackjack(player, dealer)) return@forEach
+            player.updateResult(GameResult.WIN)
+            dealer.updateResult(player.cards.calculateScore())
+        }
+    }
+
+    private fun isAllPlayerBlackjack(
+        player: Player,
+        dealer: Dealer,
+    ): Boolean {
+        if (player.isBlackjack(true)) {
+            player.updateResult(GameResult.PUSH)
+            dealer.updateResult(player.cards.calculateScore())
+            return true
+        }
+        return false
+    }
+
+    private fun playGame(
+        player: Player,
+        dealer: Dealer,
+    ) {
+        if (isPlayerBlackjack(player, dealer)) return
+        executePlayerGameLogic(player)
+        executeDealerGameLogic(dealer)
+        val dealerResult: GameResult = dealer.updateResult(dealer.cards.calculateScore())
+        player.updateResult(dealerResult)
+    }
+
+    private fun isPlayerBlackjack(
+        player: Player,
+        dealer: Dealer,
+    ): Boolean {
+        if (player.isBlackjack(true)) {
+            val dealerResult: GameResult = dealer.updateResult(CardsStatus.BLACKJACK_SCORE)
+            player.updateResult(dealerResult)
+            return true
+        }
+        return false
+    }
+
+    private fun executePlayerGameLogic(player: Player) {
+        while (!player.isBust()) {
+            outputView.printPlayerBehaviorGuide(player)
+            val playerBehavior: PlayerBehavior = inputView.readPlayerBehavior()
+
+            if (executePlayerBehavior(playerBehavior, player)) break
+        }
+    }
+
+    private fun executePlayerBehavior(
+        playerBehavior: PlayerBehavior,
+        player: Player,
+    ): Boolean {
+        when (playerBehavior) {
+            PlayerBehavior.HIT -> {
+                player.appendCard(cardDeck.pickCard())
+                outputView.printPlayerCard(player)
+                if (isPlayerBust(player)) return true
+            }
+
+            PlayerBehavior.STAY -> return true
+        }
+        return false
+    }
+
+    private fun isPlayerBust(player: Player): Boolean {
+        if (player.isBust()) {
+            outputView.printBust(player)
+            return true
+        }
+        return false
+    }
+
+    private fun executeDealerGameLogic(dealer: Dealer) {
+        while (dealer.isHit()) {
+            dealer.appendCard(cardDeck.pickCard())
+            outputView.printDealerGettingCard()
+            if (isDealerBust(dealer)) break
+        }
+    }
+
+    private fun isDealerBust(dealer: Dealer): Boolean {
+        if (dealer.isBust()) {
+            outputView.printBust(dealer)
+            return true
+        }
+        return false
+    }
+
+    private fun displayResult(
+        players: Players,
+        dealer: Dealer,
+    ) {
+        outputView.printResult(dealer, players)
+    }
+}

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

@@ -0,0 +1,10 @@
+package blackjack.model
+
+data class Card(
+    val shape: CardShape,
+    val denomination: Denomination,
+) {
+    fun isDenominationAce(card: Card): Boolean = card.denomination == Denomination.ACE
+
+    fun combine(): String = denomination.title + shape.koreanName
+}

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

@@ -0,0 +1,9 @@
+package blackjack.model
+
+class CardDeck(
+    private val cards: List<Card>,
+) {
+    private var index = 0
+
+    fun pickCard(): Card = cards[index++]
+}

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

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

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

@@ -0,0 +1,33 @@
+package blackjack.model
+
+class Cards(
+    value: List<Card>,
+) {
+    private val _value: MutableList<Card> = value.toMutableList()
+    val value: List<Card> get() = _value.map { card -> card.copy() }
+
+    var size: Int = this.value.size
+        private set
+
+    fun add(card: Card) {
+        _value.add(card)
+    }
+
+    fun isBlackjack(firstTurn: Boolean): Boolean = CardsStatus.from(calculateScore(), firstTurn) == CardsStatus.BLACKJACK
+
+    fun isBust(): Boolean = CardsStatus.from(calculateScore()) == CardsStatus.BUST
+
+    fun calculateScore(): Int {
+        val aceCount: Int = value.count { card -> card.isDenominationAce(card) }
+        val score: Int = value.sumOf { card -> card.denomination.number }
+        return when (aceCount) {
+            1 -> if (score < 11) score + 11 else score + 1
+            2 -> if (score < 10) score + 11 + 1 else score + aceCount * 1
+            3 -> if (score < 9) score + 11 + 1 + 1 else score + aceCount * 1
+            4 -> if (score < 8) score + 11 + 1 + 1 + 1 else score + aceCount * 1
+            else -> score
+        }
+    }
+
+    fun getCardsInfomation(): List<String> = value.map { it.combine() }
+}

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

@@ -0,0 +1,14 @@
+package blackjack.model
+
+object CardsMaker {
+    private val DENOMINATIONS: List<Denomination> = Denomination.entries
+    private val SHAPES: List<CardShape> = CardShape.entries
+
+    val CARDS: List<Card> =
+        DENOMINATIONS
+            .flatMap { denomination ->
+                SHAPES.map { shape ->
+                    Card(shape, denomination)
+                }
+            }.shuffled()
+}

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

@@ -0,0 +1,21 @@
+package blackjack.model
+
+enum class CardsStatus {
+    BLACKJACK,
+    BUST,
+    NONE,
+    ;
+
+    companion object {
+        const val BLACKJACK_SCORE = 21
+
+        fun from(
+            cardsScore: Int,
+            firstTurn: Boolean = false,
+        ): CardsStatus {
+            if (firstTurn && cardsScore == 21) return BLACKJACK
+            if (cardsScore > 21) return BUST
+            return NONE
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+package blackjack.model
+
+class Dealer(
+    private val dealerName: String = "딜러",
+    override val cards: Cards = Cards(mutableListOf()),
+) : Player(dealerName) {
+    private var _results: MutableMap<GameResult, Int> = mutableMapOf()
+    val results: Map<GameResult, Int> get() = _results.toMap()
+
+    override fun appendCard(card: Card) {
+        cards.add(card)
+    }
+
+    fun isHit(): Boolean {
+        val dealerScore = cards.calculateScore()
+        return PlayerBehavior.from(dealerScore) == PlayerBehavior.HIT
+    }
+
+    fun updateResult(playerScore: Int): GameResult {
+        val dealerScore: Int = cards.calculateScore()
+        val result: GameResult = GameResult.of(dealerScore, playerScore)
+        _results[result] = _results.getOrDefault(result, 0) + 1
+        return result
+    }
+}

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

@@ -0,0 +1,20 @@
+package blackjack.model
+
+enum class Denomination(
+    val title: String,
+    val number: Int,
+) {
+    ACE("A", 0),
+    TWO("2", 2),
+    THREE("3", 3),
+    FOUR("4", 4),
+    FIVE("5", 5),
+    SIX("6", 6),
+    SEVEN("7", 7),
+    EIGHT("8", 8),
+    NINE("9", 9),
+    TEN("10", 10),
+    JACK("J", 10),
+    QUEEN("Q", 10),
+    KING("K", 10),
+}