Step 2 - Blackjack

README.md

@@ -1 +1,43 @@
-# kotlin-blackjack
+# kotlin-blackjack
+
+## Blackjack 
+
+### Key objects
+Card
+
+- [x] Number cards are counted by their face value.
+- [x] Aces can count as either 1 or 11.
+
+Card Number
+
+- [x] Number or symbol (J, Q, K, A).
+- [x] Face cards (King, Queen, Jack) are each worth 10.
+
+Card Suit
+
+- [x] Contains four card suits (Spades, Hearts, Diamonds, Clubs).
+
+Deck
+
+- [x] Deck must not contain duplicated cards.
+
+Hands
+- [x] Must have two cards to be initialized.
+- [x] Should be able to add card to hands.
+
+Player
+
+- [x] Receives two cards at start of the game.
+- [x] Players can choose to draw additional cards as long as their total does not exceed 21.
+
+### States
+
+State
+- [x] Interface for all game states
+
+InitialTurn
+- [x] Should remain initial until card size is less than or equal to 2
+- [x] If hands has more than 3 cards after draw, should move state to Hit.
+
+Hit
+- [x] Can add cards until bust

src/main/kotlin/blackjack/BlackjackApplication.kt

@@ -0,0 +1,31 @@
+package blackjack
+
+import blackjack.domain.deck.Deck
+import blackjack.domain.player.Name
+import blackjack.domain.player.Player
+import blackjack.domain.player.Players
+import blackjack.view.InputView
+import blackjack.view.OutputView
+
+fun main() {
+    val rawNames = InputView.getPlayerNames()
+    val players = Players(rawNames.map(::Name).map { Player(it) })
+    val deck = Deck.create()
+
+    players.initializeState { deck.drawCard() }
+    OutputView.printInitialCards(players)
+
+    players.values.forEach { player -> player.takeTurn(deck) }
+    OutputView.printBlackjackResult(players)
+}
+
+private fun Player.takeTurn(deck: Deck) {
+    while (this.canDraw && InputView.getUserChoice(this)) {
+        this.draw(deck.drawCard())
+        OutputView.printPlayerCards(this)
+
+        if (!this.canDraw) {
+            return OutputView.announceBust(this)
+        }
+    }
+}

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

@@ -0,0 +1,27 @@
+package blackjack.domain.card
+
+class Card private constructor(
+    val number: CardNumber,
+    val suit: Suit,
+) {
+    companion object {
+        private val cache: Map<Pair<CardNumber, Suit>, Card> =
+            CardNumber.entries.flatMap { number ->
+                Suit.entries.map { suit ->
+                    Pair(Pair(number, suit), Card(number, suit))
+                }
+            }.toMap()
+
+        val cached: List<Card> = cache.values.toList()
+
+        fun of(
+            number: CardNumber,
+            suit: Suit,
+        ) = cache[Pair(number, suit)] ?: throw IllegalStateException("Card does not exist in cache.")
+
+        fun of(
+            rawNumber: String,
+            rawSuit: String,
+        ) = of(CardNumber.fromName(rawNumber), Suit.fromName(rawSuit))
+    }
+}

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

@@ -0,0 +1,24 @@
+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),
+    ;
+
+    companion object {
+        fun fromName(name: String) =
+            entries.find { it.name == name.uppercase() }
+                ?: throw IllegalArgumentException("Card number does not exist for $name")
+    }
+}

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

@@ -0,0 +1,15 @@
+package blackjack.domain.card
+
+enum class Suit {
+    SPADES,
+    HEARTS,
+    DIAMONDS,
+    CLUBS,
+    ;
+
+    companion object {
+        fun fromName(name: String) =
+            entries.find { it.name == name.uppercase() }
+                ?: throw IllegalArgumentException("Card suit does not exist for $name")
+    }
+}

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

@@ -0,0 +1,22 @@
+package blackjack.domain.deck
+
+import blackjack.domain.card.Card
+
+class Deck private constructor(
+    private val cards: MutableList<Card>,
+) {
+    init {
+        check(cards.size == cards.distinct().size) {
+            "Deck must not contain duplicated cards."
+        }
+    }
+
+    fun drawCard(): Card {
+        check(cards.isNotEmpty()) { "There are no cards left in deck." }
+        return cards.removeFirst()
+    }
+
+    companion object {
+        fun create(generator: () -> MutableList<Card> = RandomDeckGenerator::generate) = Deck(generator())
+    }
+}

src/main/kotlin/blackjack/domain/deck/DeckGenerator.kt

@@ -0,0 +1,11 @@
+package blackjack.domain.deck
+
+import blackjack.domain.card.Card
+
+interface DeckGenerator {
+    fun generate(): MutableList<Card>
+}
+
+object RandomDeckGenerator : DeckGenerator {
+    override fun generate() = Card.cached.shuffled().toMutableList()
+}

src/main/kotlin/blackjack/domain/player/Hands.kt

@@ -0,0 +1,35 @@
+package blackjack.domain.player
+
+import blackjack.domain.card.Card
+import blackjack.domain.card.CardNumber
+
+class Hands(
+    val cards: List<Card> = emptyList(),
+) {
+    val initialized
+        get() = cards.size >= 2
+
+    val size: Int
+        get() = cards.size
+
+    infix operator fun plus(card: Card) = Hands(cards + card)
+
+    fun isBust(): Boolean = calculateScore() > BLACKJACK_SCORE
+
+    fun calculateScore(): Int {
+        val sum = cards.sumOf { it.number.value }
+
+        return when {
+            !hasAce() -> sum
+            sum + ACE_ADD_SCORE > BLACKJACK_SCORE -> sum
+            else -> sum + ACE_ADD_SCORE
+        }
+    }
+
+    fun hasAce() = cards.map { it.number }.contains(CardNumber.ACE)
+
+    companion object {
+        private const val BLACKJACK_SCORE = 21
+        private const val ACE_ADD_SCORE = 10
+    }
+}

src/main/kotlin/blackjack/domain/player/Name.kt

@@ -0,0 +1,7 @@
+package blackjack.domain.player
+
+class Name(val value: String) {
+    init {
+        require(value.trim().isNotEmpty()) { "Name can't be empty." }
+    }
+}

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

@@ -0,0 +1,29 @@
+package blackjack.domain.player
+
+import blackjack.domain.card.Card
+import blackjack.domain.state.InitialState
+import blackjack.domain.state.State
+
+class Player(
+    val name: Name,
+    _state: State = InitialState(),
+) {
+    var state = _state
+        private set
+
+    val cards: List<Card>
+        get() = state.hands.cards
+
+    val canDraw: Boolean
+        get() = state.canContinue
+
+    val score: Int?
+        get() = state.score
+
+    constructor(rawName: String) : this(Name(rawName))
+    constructor(rawName: String, state: State) : this(Name(rawName), state)
+
+    fun draw(card: Card) {
+        state = state.addCard(card)
+    }
+}

src/main/kotlin/blackjack/domain/player/Players.kt

@@ -0,0 +1,21 @@
+package blackjack.domain.player
+
+import blackjack.domain.card.Card
+
+class Players(
+    val values: List<Player>,
+) {
+    val names = values.map { it.name.value }
+
+    constructor(vararg rawNames: String) : this(rawNames.map { Player(Name(it)) })
+
+    fun initializeState(block: () -> Card) {
+        repeat(FIRST_TURN_REPETITIONS) {
+            values.forEach { it.draw(block()) }
+        }
+    }
+
+    companion object {
+        private const val FIRST_TURN_REPETITIONS = 2
+    }
+}

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

@@ -0,0 +1,15 @@
+package blackjack.domain.state
+
+import blackjack.domain.card.Card
+import blackjack.domain.player.Hands
+
+class Bust(override val hands: Hands) : State {
+    override val canContinue = false
+
+    override val score: Int?
+        get() = null
+
+    override fun addCard(card: Card): State {
+        throw IllegalStateException("Can't add card after bust.")
+    }
+}

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

@@ -0,0 +1,18 @@
+package blackjack.domain.state
+
+import blackjack.domain.card.Card
+import blackjack.domain.player.Hands
+
+class Hit(override val hands: Hands) : State {
+    override val score: Int?
+        get() = hands.calculateScore()
+
+    override fun addCard(card: Card): State {
+        val hands = hands + card
+        if (hands.isBust()) {
+            return Bust(hands)
+        }
+
+        return Hit(hands)
+    }
+}

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

@@ -0,0 +1,18 @@
+package blackjack.domain.state
+
+import blackjack.domain.card.Card
+import blackjack.domain.player.Hands
+
+class InitialState(override val hands: Hands = Hands()) : State {
+    override val score: Int?
+        get() = hands.calculateScore()
+
+    override fun addCard(card: Card): State {
+        val hands = hands + card
+        if (!hands.initialized) {
+            return InitialState(hands)
+        }
+
+        return Hit(hands)
+    }
+}

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

@@ -0,0 +1,15 @@
+package blackjack.domain.state
+
+import blackjack.domain.card.Card
+import blackjack.domain.player.Hands
+
+interface State {
+    val hands: Hands
+
+    val canContinue: Boolean
+        get() = true
+
+    val score: Int?
+
+    fun addCard(card: Card): State
+}

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

@@ -0,0 +1,35 @@
+package blackjack.view
+
+import blackjack.domain.player.Player
+
+object InputView {
+    fun getPlayerNames(): List<String> {
+        println("Enter the names of the players (comma-separated):")
+
+        return readln()
+            .split(",")
+            .map { it.trim() }
+            .filter { it.isNotBlank() }
+    }
+
+    fun getUserChoice(player: Player): Boolean {
+        println("Would ${player.name.value} like to draw another card? (y for yes, n for no)")
+        val input = readln()
+
+        return UserChoice.from(input).value
+    }
+}
+
+enum class UserChoice(val value: Boolean) {
+    Y(true),
+    N(false),
+    ;
+
+    companion object {
+        fun from(input: String): UserChoice {
+            return entries.find {
+                it.name == input.uppercase()
+            } ?: throw IllegalArgumentException("Invalid user choice: $input")
+        }
+    }
+}