Step2 - 블랙잭

README.md

@@ -1 +1,19 @@
-# kotlin-blackjack
+# kotlin-blackjack
+
+[x] 숫자와 문양을 가진 카드 구현
+
+[x] 카드 뭉치인 덱 구현
+
+[x] 점수 합계를 계산할 수 있는 카드목록 구현
+
+[x] 이름과 카드 목록을 가질 수 있는 플레이어 구현
+
+[x] 카드를 두 장 받는 기능 구현
+
+[x] 카드를 한 장 더 받는 기능 구현
+
+[x] 21이 초과했는지 판별하는 기능 구현
+
+[x] 카드를 그만 받는 기능 구현
+
+[x] 입출력 기능 구현

src/main/kotlin/blackjack/Main.kt

@@ -0,0 +1,41 @@
+package blackjack
+
+import blackjack.domain.BlackJack
+import blackjack.domain.Deck
+import blackjack.domain.OnGoingPlayer
+import blackjack.domain.Player
+import blackjack.view.InputView
+import blackjack.view.OutputView
+
+fun main() {
+    val players = InputView.getPlayers()
+
+    val blackJack = BlackJack(Deck())
+
+    val finishedPlayers: List<Player> = blackJack.play(players)
+        .onEach { OutputView.printCards(it) }
+        .map { player ->
+            var onGoingPlayer = player
+
+            while (true) {
+                if (onGoingPlayer !is OnGoingPlayer) {
+                    break
+                }
+
+                val isHit = InputView.isHit(onGoingPlayer.name)
+
+                if (!isHit) {
+                    break
+                }
+
+                onGoingPlayer = blackJack.hit(onGoingPlayer)
+                OutputView.printCards(onGoingPlayer)
+            }
+
+            onGoingPlayer
+        }
+
+    finishedPlayers.forEach {
+        OutputView.printResult(it)
+    }
+}

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

@@ -0,0 +1,32 @@
+package blackjack.domain
+
+class BlackJack(
+    private val deck: Deck,
+) {
+    fun play(players: List<PreparedPlayer>): List<Player> {
+        return players.map { player ->
+            val drawnCards = Cards(
+                listOf(
+                    deck.draw(),
+                    deck.draw(),
+                )
+            )
+
+            OnGoingPlayer.of(player.name, drawnCards)
+        }
+    }
+
+    fun hit(player: OnGoingPlayer): Player {
+        val drawnCard = deck.draw()
+
+        return OnGoingPlayer.of(player.name, player.cards + drawnCard)
+    }
+
+    fun stay(player: Player): FinishedPlayer {
+        return FinishedPlayer(player)
+    }
+
+    companion object {
+        const val BlackJackedNumber = 21
+    }
+}

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

@@ -0,0 +1,6 @@
+package blackjack.domain
+
+class BlackJackedPlayer(
+    override val name: String,
+    override val cards: Cards,
+) : Player

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

@@ -0,0 +1,6 @@
+package blackjack.domain
+
+class BustedPlayer(
+    override val name: String,
+    override val cards: Cards,
+) : Player

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

@@ -0,0 +1,6 @@
+package blackjack.domain
+
+data class Card(
+    val suit: Suit,
+    val rank: Rank,
+)

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

@@ -0,0 +1,5 @@
+package blackjack.domain
+
+fun interface CardPointStrategy {
+    fun getPoint(rank: Rank): Int
+}

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

@@ -0,0 +1,20 @@
+package blackjack.domain
+
+@JvmInline
+value class Cards(val value: List<Card>) {
+    fun getPoints(): Int {
+        val hardAcePoint = value.sumOf { card ->
+            HardAcePointStrategy().getPoint(card.rank)
+        }
+
+        val softAcePointStrategy = value.sumOf { card ->
+            SoftAcePointStrategy().getPoint(card.rank)
+        }
+
+        return softAcePointStrategy.takeIf { it <= BlackJack.BlackJackedNumber } ?: hardAcePoint
+    }
+
+    operator fun plus(other: Card): Cards {
+        return Cards(value + other)
+    }
+}

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

@@ -0,0 +1,23 @@
+package blackjack.domain
+
+class Deck {
+    private val cards = ArrayList<Card>(setupDeck())
+
+    fun draw(): Card {
+        check(cards.isNotEmpty()) {
+            "덱에 남아있는 카드가 없습니다."
+        }
+
+        return cards.removeFirst()
+    }
+
+    private fun setupDeck(): List<Card> {
+        return Suit.values()
+            .flatMap { suit ->
+                Rank.values().map { rank ->
+                    Card(suit, rank)
+                }
+            }
+            .shuffled()
+    }
+}

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

@@ -0,0 +1,3 @@
+package blackjack.domain
+
+class FinishedPlayer(player: Player) : Player by player

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

@@ -0,0 +1,7 @@
+package blackjack.domain
+
+class HardAcePointStrategy : CardPointStrategy {
+    override fun getPoint(rank: Rank): Int {
+        return rank.value
+    }
+}

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

@@ -0,0 +1,20 @@
+package blackjack.domain
+
+class OnGoingPlayer(
+    override val name: String,
+    override val cards: Cards,
+) : Player {
+    companion object {
+        fun of(name: String, cards: Cards): Player {
+            val hardAcePoint = cards.getPoints()
+
+            return if (hardAcePoint == BlackJack.BlackJackedNumber) {
+                BlackJackedPlayer(name, cards)
+            } else if (hardAcePoint > BlackJack.BlackJackedNumber) {
+                BustedPlayer(name, cards)
+            } else {
+                OnGoingPlayer(name, cards)
+            }
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+package blackjack.domain
+
+interface Player {
+    val name: String
+    val cards: Cards
+}

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

@@ -0,0 +1,7 @@
+package blackjack.domain
+
+class PreparedPlayer(
+    override val name: String,
+) : Player {
+    override val cards: Cards = Cards(emptyList())
+}

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

@@ -0,0 +1,17 @@
+package blackjack.domain
+
+enum class Rank(val value: Int, val nameValue: String) {
+    Ace(1, "1"),
+    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(10, "J"),
+    Queen(10, "Q"),
+    King(10, "K"),
+}

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

@@ -0,0 +1,10 @@
+package blackjack.domain
+
+class SoftAcePointStrategy : CardPointStrategy {
+    override fun getPoint(rank: Rank): Int {
+        return when(rank) {
+            Rank.Ace -> 11
+            else -> rank.value
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+package blackjack.domain
+
+enum class Suit(val value: String) {
+    Spade("스페이드"),
+    Club("클로버"),
+    Diamond("다이아몬드"),
+    Heart("하트"),
+}

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

@@ -0,0 +1,22 @@
+package blackjack.view
+
+import blackjack.domain.PreparedPlayer
+
+object InputView {
+    fun getPlayers(): List<PreparedPlayer> {
+        println("게임에 참여할 사람의 이름을 입력하세요.(쉼표 기준으로 분리)")
+
+        return readln().split(",")
+            .map { PreparedPlayer(it) }
+    }
+
+    fun isHit(name: String): Boolean {
+        println("${name}는 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)")
+
+        return when (readln()) {
+            "y" -> true
+            "n" -> false
+            else -> error("y/n 으로만 입력해주세요")
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+package blackjack.view
+
+import blackjack.domain.Player
+
+object OutputView {
+    fun printCards(player: Player) {
+        println("${player.name}카드: ${player.cards.value.joinToString { "${it.rank.nameValue}${it.suit.value}" }}")
+    }
+
+    fun printResult(player: Player) {
+        println(
+            "${player.name}카드: ${player.cards.value.joinToString { "${it.rank.nameValue}${it.suit.value}" }} - 결과: ${
+                player.cards.getPoints()
+            }"
+        )
+    }
+}

src/test/kotlin/blackjack/domain/BlackJackTest.kt

@@ -0,0 +1,80 @@
+package blackjack.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class BlackJackTest {
+    @Test
+    fun `PreparedPlayer는 카드 두 장을 받은 OngoingPlayer가 된다`() {
+        val deck = Deck()
+        val blackJack = BlackJack(deck)
+
+        val preparedPlayers = listOf(PreparedPlayer("a"))
+        val onGoingPlayers = blackJack.play(preparedPlayers)
+
+        val actualCardsCount = onGoingPlayers.first().cards.value.size
+        val expectedCardsCount = 2
+
+        assertThat(actualCardsCount).isEqualTo(expectedCardsCount)
+    }
+
+    @Test
+    fun `PreparedPlayer는 OngoingPlayer가 되더라도 이름이 유지된다`() {
+        val deck = Deck()
+        val blackJack = BlackJack(deck)
+
+        val preparedPlayers = listOf(PreparedPlayer("a"))
+        val onGoingPlayers = blackJack.play(preparedPlayers)
+
+        val actualPlayerName = onGoingPlayers.first().name
+        val expectedPlayerName = "a"
+
+        assertThat(actualPlayerName).isEqualTo(expectedPlayerName)
+    }
+
+    @Test
+    fun `진행중인 플레이어는 카드를 더 뽑을 수 있다`() {
+        val deck = Deck()
+        val blackJack = BlackJack(deck)
+        val player = OnGoingPlayer("a", Cards(listOf()))
+
+        val onGoingPlayer = blackJack.hit(player)
+
+        val actualCardsCount = onGoingPlayer.cards.value.size
+        val expectedCardsCount = 1
+
+        assertThat(actualCardsCount).isEqualTo(expectedCardsCount)
+    }
+
+    @Test
+    fun `카드를 뽑았을 때 21을 초과하면 버스트된 플레이어가 된다`() {
+        val deck = Deck()
+        val blackJack = BlackJack(deck)
+        val cards = Cards(
+            listOf(
+                Card(Suit.Spade, Rank.Ten),
+                Card(Suit.Spade, Rank.Ten),
+                Card(Suit.Spade, Rank.Ace),
+            )
+        )
+        val player = OnGoingPlayer("a", cards)
+
+        val bustedPlayer = blackJack.hit(player)
+
+        assertThat(bustedPlayer).isInstanceOf(BustedPlayer::class.java)
+    }
+
+    @Test
+    fun `스테이 하면 종료한 플레이어가 된다`() {
+        val deck = Deck()
+        val blackJack = BlackJack(deck)
+        val player = object : Player {
+            override val name: String = ""
+            override val cards: Cards = Cards(emptyList())
+        }
+
+        val finishedPlayer = blackJack.stay(player)
+
+        assertThat(finishedPlayer).isInstanceOf(FinishedPlayer::class.java)
+    }
+}