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

README.md

@@ -1 +1,20 @@
-# kotlin-blackjack
+# kotlin-blackjack
+
+- [x] 사용자는 게임에 참여할 인원들의 이름을 입력한다.
+- [x] 사용자는 각 참여자가 카드를 받을지 받지 않을지 입력한다.
+- [x] 참여자들의 이름과 나누어진 카드의 개수를 출력한다.
+- [x] 참여자가 보유한 카드의 목록을 출력한다.
+- [x] 참여자의 결과를 출력한다.
+- [x] 카드는 문양과 등급을 가진다.
+- [x] 플레이어는 이름과 사용할 카드를 가진다.
+- [x] 플레잉 카드의 등급을 만든다.
+- [x] 플레잉 카드의 문양을 만든다.
+- [x] 카드들에서 카드를 뽑는다.
+- [x] 플레이어가 카드를 받는다.
+- [x] 딜러는 이름과 사용할 카드를 가진다.
+- [x] 딜러가 카드를 받는다.
+- [x] 플레이어는 총 점수를 반환한다.
+- [x] 딜러는 총 점수를 반환한다.
+- [x] 각 플레이어의 승패를 반환한다.
+- [x] 딜러의 승패들을 반환한다.
+- [x] 오류 발생시에 재입력 기능 구현

src/main/kotlin/Main.kt

@@ -0,0 +1,6 @@
+import blackjack.controller.GameController
+
+fun main() {
+    val gameController = GameController()
+    gameController.run()
+}

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

@@ -0,0 +1,87 @@
+package blackjack.controller
+
+import blackjack.domain.model.Action
+import blackjack.domain.model.Dealer
+import blackjack.domain.model.Deck
+import blackjack.domain.model.Participant
+import blackjack.domain.model.Player
+import blackjack.view.InputView
+import blackjack.view.OutputView
+
+class GameController(
+    private val inputView: InputView = InputView(),
+    private val outputView: OutputView = OutputView(),
+) {
+    fun run() {
+        val deck = Deck()
+        val dealer = Dealer()
+        val players: List<Player> = inputView.readPlayerNames().map(::Player)
+        processInitialDeals(deck, listOf(dealer) + players)
+        announceInitialDeals(dealer, players)
+
+        players.forEach { player -> processPlayerHits(deck, player) }
+        processDealerHits(deck, dealer)
+
+        announceResults(dealer, players)
+    }
+
+    private fun processInitialDeals(
+        deck: Deck,
+        participants: List<Participant>,
+    ) {
+        participants.forEach { player ->
+            player.accept(deck.draw(Participant.INITIAL_DRAW_COUNT))
+        }
+    }
+
+    private fun announceInitialDeals(
+        dealer: Dealer,
+        players: List<Player>,
+    ) {
+        outputView.printInitialDeals(dealer, players)
+        outputView.printParticipantStatus(dealer, players)
+    }
+
+    private fun processPlayerHits(
+        deck: Deck,
+        player: Player,
+    ) {
+        if (!player.canHit()) return
+        val action = inputView.readPlayerAction(player)
+        if (action == Action.STAND) {
+            printStatusOnNoHit(player)
+            return
+        }
+        player.accept(deck.draw())
+        outputView.printPlayerStatus(player)
+        processPlayerHits(deck, player)
+    }
+
+    private fun printStatusOnNoHit(player: Player) {
+        if (player.showHand().count() == Participant.INITIAL_DRAW_COUNT) outputView.printPlayerStatus(player)
+    }
+
+    private fun processDealerHits(
+        deck: Deck,
+        dealer: Dealer,
+    ) {
+        while (dealer.canHit()) {
+            outputView.printDealerHit()
+            dealer.accept(deck.draw())
+        }
+    }
+
+    private fun announceResults(
+        dealer: Dealer,
+        players: List<Player>,
+    ) {
+        outputView.printPlayerResult(dealer)
+        players.forEach { player -> outputView.printPlayerResult(player) }
+
+        outputView.printResultsHeader()
+        val playerResults = dealer.getPlayerResult(players)
+        val dealerResults = dealer.getDealerResults(playerResults)
+        outputView.printDealerResults(dealer, dealerResults)
+        playerResults.forEach { (player, result) -> outputView.printPlayerResult(player, result) }
+    }
+}

src/main/kotlin/blackjack/domain/model/Action.kt

@@ -0,0 +1,6 @@
+package blackjack.domain.model
+
+enum class Action {
+    HIT,
+    STAND,
+}

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

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

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

@@ -0,0 +1,26 @@
+package blackjack.domain.model
+
+class Dealer(name: String = DEALER_NAME) : Participant(name) {
+    constructor(name: String = DEALER_NAME, cards: List<Card>) : this(name) {
+        accept(cards)
+    }
+
+    override fun canHit(): Boolean {
+        return (computePoint() <= DEALER_HIT_THRESHOLD)
+    }
+
+    fun getPlayerResult(players: List<Player>): Map<Player, Result> {
+        return players.associateWith { player -> player.compareAgainst(this) }
+    }
+
+    fun getDealerResults(playerResults: Map<Player, Result>): Map<Result, Int> {
+        return Result.entries.associateWith { result ->
+            playerResults.values.count { playerResult -> result == playerResult.reverse() }
+        }
+    }
+
+    companion object {
+        const val DEALER_NAME = "딜러"
+        const val DEALER_HIT_THRESHOLD = 16
+    }
+}

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

@@ -0,0 +1,20 @@
+package blackjack.domain.model
+
+class Deck(cards: List<Card> = pack.shuffled()) {
+    private val cards: MutableList<Card> = cards.toMutableList()
+
+    fun draw(count: Int = Participant.DEFAULT_DRAW_COUNT): List<Card> {
+        if (cards.count() < count) cards.addAll(cards.shuffled())
+        return List(count.coerceAtMost(count)) { cards.removeFirst() }
+    }
+
+    companion object {
+        private val pack = Suit.entries.flatMap { suit -> makeCardsFrom(suit) }
+
+        private fun makeCardsFrom(suit: Suit): List<Card> {
+            return Rank.entries.map { rank ->
+                Card(suit, rank)
+            }
+        }
+    }
+}

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

@@ -0,0 +1,35 @@
+package blackjack.domain.model
+
+class Hand() {
+    private val _cards: MutableList<Card> = mutableListOf()
+    val cards: List<Card> get() = _cards.toList()
+
+    constructor(cards: List<Card>) : this() {
+        add(cards)
+    }
+
+    fun add(cards: List<Card>) {
+        _cards.addAll(cards)
+    }
+
+    fun computePoint(): Int {
+        val point = _cards.sumOf { it.rank.point }
+        return point + computeBonusPoint(point)
+    }
+
+    private fun computeBonusPoint(point: Int): Int {
+        if (point + BONUS_POINT <= BUST_THRESHOLD && hasAce()) return BONUS_POINT
+        return 0
+    }
+
+    private fun hasAce(): Boolean = _cards.any { it.rank == Rank.ACE }
+
+    fun isBusted(): Boolean {
+        return computePoint() > BUST_THRESHOLD
+    }
+
+    companion object {
+        private const val BUST_THRESHOLD = 21
+        private const val BONUS_POINT = 10
+    }
+}

src/main/kotlin/blackjack/domain/model/Participant.kt

@@ -0,0 +1,34 @@
+package blackjack.domain.model
+
+abstract class Participant(val name: String) {
+    private val hand = Hand()
+
+    init {
+        require(name.isNotBlank()) { ERROR_MESSAGE_BLANK_PARTICIPANT_NAME }
+    }
+
+    fun showHand(count: Int = hand.cards.size): List<Card> {
+        return hand.cards.take(count).map { card -> card.copy() }
+    }
+
+    fun accept(cards: List<Card>) {
+        hand.add(cards)
+    }
+
+    fun computePoint(): Int {
+        return hand.computePoint()
+    }
+
+    fun isBusted(): Boolean {
+        return hand.isBusted()
+    }
+
+    abstract fun canHit(): Boolean
+
+    companion object {
+        const val INITIAL_DRAW_COUNT = 2
+        const val DEFAULT_DRAW_COUNT = 1
+
+        private const val ERROR_MESSAGE_BLANK_PARTICIPANT_NAME = "참가자의 이름은 공백일 수 없습니다."
+    }
+}

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

@@ -0,0 +1,24 @@
+package blackjack.domain.model
+
+class Player(name: String) : Participant(name) {
+    constructor(name: String, cards: List<Card>) : this(name) {
+        accept(cards)
+    }
+
+    override fun canHit(): Boolean {
+        return !isBusted()
+    }
+
+    fun compareAgainst(dealer: Dealer): Result {
+        if (isBusted()) return Result.LOSE
+        if (dealer.isBusted()) return Result.WIN
+
+        val point: Int = computePoint()
+        val dealerPoint: Int = dealer.computePoint()
+        return when {
+            point > dealerPoint -> Result.WIN
+            point < dealerPoint -> Result.LOSE
+            else -> Result.DRAW
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+package blackjack.domain.model
+
+enum class Rank(val point: 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/model/Result.kt

@@ -0,0 +1,16 @@
+package blackjack.domain.model
+
+enum class Result {
+    WIN,
+    LOSE,
+    DRAW,
+    ;
+
+    fun reverse(): Result {
+        return when (this) {
+            WIN -> LOSE
+            LOSE -> WIN
+            else -> DRAW
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+package blackjack.domain.model
+
+enum class Suit {
+    HEART,
+    SPADE,
+    DIAMOND,
+    CLUB,
+}

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

@@ -0,0 +1,51 @@
+package blackjack.view
+
+import blackjack.domain.model.Action
+import blackjack.domain.model.Player
+
+class InputView {
+    fun readPlayerNames(): List<String> {
+        println(MESSAGE_REQUEST_PLAYER_NAMES)
+        val input: String = readInput()
+        return input.split(PLAYER_NAMES_DELIMITER).map { name: String -> name.trim() }
+    }
+
+    fun readPlayerAction(player: Player): Action {
+        return readUntilValid {
+            println(MESSAGE_REQUEST_PLAYER_YES_OR_NO.format(player.name))
+            val input: String = readInput().lowercase()
+            convertToAction(input)
+        }
+    }
+
+    private fun convertToAction(input: String): Action {
+        return when (input) {
+            PLAYER_ACTION_YES -> Action.HIT
+            PLAYER_ACTION_NO -> Action.STAND
+            else -> throw IllegalArgumentException(MESSAGE_ERROR_INVALID_CHOICE)
+        }
+    }
+
+    private fun readInput(): String {
+        val input: String = readln()
+        println()
+        return input
+    }
+
+    private fun <T> readUntilValid(event: () -> T): T {
+        while (true) {
+            kotlin.runCatching { event() }.onSuccess { return it }
+                .onFailure { println(it.message ?: it.stackTraceToString()) }
+        }
+    }
+
+    companion object {
+        private const val MESSAGE_REQUEST_PLAYER_NAMES = "게임에 참여할 사람의 이름을 입력하세요.(쉼표 기준으로 분리)"
+        private const val MESSAGE_REQUEST_PLAYER_YES_OR_NO = "%s은(는) 한 장의 카드를 더 받겠습니까? (예는 y, 아니오는 n)"
+        private const val MESSAGE_ERROR_INVALID_CHOICE = "y 또는 n을 입력해주세요."
+
+        private const val PLAYER_ACTION_YES = "y"
+        private const val PLAYER_ACTION_NO = "n"
+        private const val PLAYER_NAMES_DELIMITER = ","
+    }
+}