🚀 3단계 - 블랙잭(딜러)

README.md

@@ -65,3 +65,26 @@ Player.hit() :  블랙잭에서 카드를 받는 행동은 "히트" 딜러가 
 - 매직넘버, 매직스트링을 상수로 분리해내기 (특히 view, model)
 - 어떤 테스트코드가 필요한지 생각하고(뭘 구현해야하지, 뭐가 요구조건인지 리마인드) >> 테스트코드를 작성하고 >> 테스트할수 있도록 리팩토링하기
 ```
+
+<br><br>
+
+## 🚀 3단계 - 블랙잭(딜러)
+
+- 요구사항 분석
+```text
+- 딜러 기능을 구현
+  - 딜러와 플레이어 중 카드의 합이 21 또는 21에 가장 가까운 숫자를 가지는 쪽이 이기는 기능을 구현
+  - 딜러는 처음에 받은 2장의 합계가 16이하이면 반드시 1장의 카드를 추가로 받아야 하고, 17점 이상이면 추가로 받을 수 없다
+    - 딜러의 히트/스텐드 전략은 자동이라는 의미임. 테스트코드 작성 필요
+
+- 심판기능(Referee) : 점수계산 $& 승패를 판단 
+  - 딜러가 21을 초과하면 그 시점까지 남아 있던 플레이어들은 가지고 있는 패에 상관 없이 승리한다.
+  - 블랙잭 게임은 딜러와 플레이어 중 카드의 합이 21 또는 21에 가장 가까운 숫자를 가지는 쪽이 이긴다
+
+-입출력 기능
+  - 게임을 완료한 후 각 플레이어별로 승패를 출력
+
+```
+
+
+walkover - 부전승, 낙승 : 상대방(딜러의 몰수패로 이기는)

src/main/kotlin/blackjack/Controller.kt

@@ -1,30 +1,16 @@
 package blackjack
 
-import blackjack.model.Participants
-import blackjack.model.Player
+import blackjack.model.BlackJackGame
+import blackjack.model.pack.impl.ShuffledPack
 import blackjack.view.InputView
 import blackjack.view.OutputView
 
 fun main() {
     val participants = InputView.join()
-    participants.dealing()
+    participants.dealing(ShuffledPack)
     OutputView.dealing(participants)
     OutputView.presentCards(participants)
-    while (participants.isContinue()) {
-        playingBlackJack(participants)
-    }
-    OutputView.result(participants)
-}
-
-fun playingBlackJack(participants: Participants) {
-    participants.participants.forEach {
-        it.hitOrStand()
-    }
-}
-
-private fun Player.hitOrStand() {
-    if (InputView.askHit(this)) {
-        this.hit()
-    }
-    OutputView.playerCardPresent(this)
+    BlackJackGame(participants, ShuffledPack).start()
+    OutputView.presentScores(participants)
+    OutputView.presentResult(participants)
 }

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

@@ -0,0 +1,32 @@
+package blackjack.model
+
+import blackjack.model.pack.Pack
+import blackjack.model.playblestrategy.PlayingStrategy
+import blackjack.model.playblestrategy.impl.DealerStrategy
+import blackjack.view.OutputView
+
+class BlackJackGame(
+    private val participants: Participants,
+    private val pack: Pack,
+) {
+    fun start() {
+        while (participants.isContinue()) {
+            playingBlackJackTurn(pack)
+        }
+    }
+
+    private fun playingBlackJackTurn(pack: Pack) {
+        playersTurn(pack)
+        val dealerScore = participants.dealer.score()
+        dealerTurn(DealerStrategy(dealerScore), pack)
+    }
+
+    private fun dealerTurn(playingStrategy: PlayingStrategy, pack: Pack) {
+        val playing = participants.dealer.playing(playingStrategy, pack)
+        OutputView.presentDealerAction(playing)
+    }
+
+    private fun playersTurn(pack: Pack) {
+        participants.players.playingTurn(pack)
+    }
+}

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

@@ -0,0 +1,6 @@
+package blackjack.model
+
+enum class BlackJackStatus {
+    ALIVE,
+    DIE,
+}

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

@@ -1,21 +1,23 @@
 package blackjack.model
 
+import blackjack.model.pack.Pack
+import blackjack.model.playable.impl.Dealer
+
 class Participants(
-    val participants: Set<Player>,
+    val players: Players,
+    val dealer: Dealer,
 ) {
-    fun count(): Int {
-        return participants.size
-    }
 
-    fun dealing() {
-        participants.forEach { it.deal() }
+    fun dealing(pack: Pack) {
+        players.dealing(pack)
+        dealer.dealing(pack)
     }
 
-    private fun isGameOver(): Boolean {
-        return participants.none { Referee.isBlackJack(it) }
+    fun isContinue(): Boolean {
+        return players.hasAnyAlivePlayer() && dealer.isNotBurst()
     }
 
-    fun isContinue(): Boolean {
-        return !isGameOver()
+    fun count(): Int {
+        return players.count() + 1
     }
 }

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

@@ -0,0 +1,45 @@
+package blackjack.model
+
+import blackjack.model.pack.Pack
+import blackjack.model.playable.PlayableResult
+import blackjack.model.playable.impl.Dealer
+import blackjack.model.playable.impl.Player
+import blackjack.model.playblestrategy.impl.ConsoleInputStrategy
+
+class Players(
+    val values: Set<Player>,
+) {
+    init {
+        require(values.map { it.name }.distinct().size == values.size) { "Player 들의 이름은 중복이 허용되지 않습니다" }
+    }
+
+    constructor(vararg players: Player) : this(players.toSet())
+
+    fun dealing(pack: Pack) {
+        values.forEach { it.dealing(pack) }
+    }
+
+    fun hasAnyAlivePlayer(): Boolean {
+        val burstPlayers: List<Boolean> = values.map { it.status() == BlackJackStatus.ALIVE }.toList()
+        return burstPlayers.contains(true)
+    }
+
+    fun count(): Int {
+        return values.size
+    }
+
+    fun playingTurn(pack: Pack) {
+        values.forEach { player ->
+            if (player.status() == BlackJackStatus.ALIVE) {
+                player.playing(ConsoleInputStrategy(player), pack)
+            }
+//            else {
+//                println("   ### [검증용/삭제예정] 플레이어 ${player.name} 은 DIE 상태라 카드를 받을수 있는 기회가 주어지지 않습니다, score=${player.cards.totalScore()}")
+//            }
+        }
+    }
+
+    fun results(dealer: Dealer): List<Pair<Player, PlayableResult>> {
+        return this.values.map { it to it.result(dealer) }
+    }
+}

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

@@ -1,20 +1,20 @@
-package blackjack.model
+package blackjack.model.card
 
 class Card private constructor(
     val suit: Suit,
     val cardRank: CardRank,
 ) {
     companion object {
-        private val CARDS: Map<Pair< Suit, CardRank>, Card> by lazy {
+        private val CARDS: Map<Trump, Card> by lazy {
             Suit.values().flatMap { suit ->
                 CardRank.values().map { rank ->
-                    (suit to rank) to Card(suit, rank)
+                    Trump(suit to rank) to Card(suit, rank)
                 }
             }.toMap()
         }
 
         fun of(suit: Suit, cardRank: CardRank): Card {
-            return requireNotNull(this.CARDS[suit to cardRank]) { "입력된 suit=[$suit] , cardRank=[$cardRank] 는 찾을수 없습니다" }
+            return requireNotNull(CARDS[Trump(suit to cardRank)]) { "입력된 suit=[$suit] , cardRank=[$cardRank] 는 찾을수 없습니다" }
         }
     }
 }

src/main/kotlin/blackjack/model/CardRank.kt → src/main/kotlin/blackjack/model/card/CardRank.kt

@@ -1,4 +1,4 @@
-package blackjack.model
+package blackjack.model.card
 
 enum class CardRank(
     val score: Int,

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

@@ -1,4 +1,6 @@
-package blackjack.model
+package blackjack.model.card
+
+import blackjack.model.playable.BlackjackScore
 
 class Cards(
     cards: List<Card> = emptyList(),
@@ -10,11 +12,11 @@ class Cards(
         _cards.add(card)
     }
 
-    fun totalScore(): Int {
+    fun totalScore(): BlackjackScore {
         if (this.isContainsAce()) {
-            return scoreWithAce()
+            return BlackjackScore(scoreWithAce())
         }
-        return simpleSumOfScore()
+        return BlackjackScore(simpleSumOfScore())
     }
 
     private fun simpleSumOfScore(): Int {
@@ -28,10 +30,10 @@ class Cards(
 
     private fun scoreWithAce(): Int {
         val simpleSum = simpleSumOfScore()
-        if (simpleSum + ALTERNATIVE_ACE_SCORE_DIFF > HIGHEST_SCORE) {
+        if (simpleSum + ACE_BONUS_SCORE > HIGHEST_SCORE) {
             return simpleSum
         }
-        return simpleSum + ALTERNATIVE_ACE_SCORE_DIFF
+        return simpleSum + ACE_BONUS_SCORE
     }
 
     fun count(): Int {
@@ -40,7 +42,7 @@ class Cards(
 
     companion object {
         private const val HIGHEST_SCORE: Int = 21
-        private const val ALTERNATIVE_ACE_SCORE_DIFF: Int = 11 - 1
+        private const val ACE_BONUS_SCORE: Int = 10
 
         fun emptyCards(): Cards {
             return Cards(mutableListOf())

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

@@ -0,0 +1,11 @@
+package blackjack.model.card
+
+enum class Suit(
+    val alias: String,
+) {
+    SPADE("스페이드"),
+    HEART("하트"),
+    DIAMOND("다이아"),
+    CLOVER("클로버"),
+    ;
+}

src/main/kotlin/blackjack/model/card/Trump.kt

@@ -0,0 +1,6 @@
+package blackjack.model.card
+
+@JvmInline
+value class Trump(
+    val trump: Pair<Suit, CardRank>,
+)

src/main/kotlin/blackjack/model/pack/Pack.kt

@@ -1,6 +1,6 @@
 package blackjack.model.pack
 
-import blackjack.model.Card
+import blackjack.model.card.Card
 
 interface Pack {
     fun pickCard(): Card

src/main/kotlin/blackjack/model/pack/ShuffledPack.kt → src/main/kotlin/blackjack/model/pack/impl/ShuffledPack.kt

@@ -1,8 +1,9 @@
-package blackjack.model.pack
+package blackjack.model.pack.impl
 
-import blackjack.model.Card
-import blackjack.model.CardRank
-import blackjack.model.Suit
+import blackjack.model.card.Card
+import blackjack.model.card.CardRank
+import blackjack.model.card.Suit
+import blackjack.model.pack.Pack
 import kotlin.random.Random
 
 object ShuffledPack : Pack {
@@ -21,6 +22,6 @@ object ShuffledPack : Pack {
     }
 
     private fun randomInRange(range: Int): Int {
-        return this.random.nextInt(0, Int.MAX_VALUE) % range
+        return random.nextInt(0, Int.MAX_VALUE) % range
     }
 }

src/main/kotlin/blackjack/model/playable/BlackjackScore.kt

@@ -0,0 +1,28 @@
+package blackjack.model.playable
+
+@JvmInline
+value class BlackjackScore(
+    val value: Int
+) {
+    infix fun vs(other: BlackjackScore): PlayableResult {
+        if (this.value == other.value) {
+            return PlayableResult.DRAW
+        }
+        if (this.value > other.value) {
+            return PlayableResult.WIN
+        }
+        return PlayableResult.LOSE
+    }
+
+    fun isBurst(): Boolean {
+        return this.value > BLACK_JACK_SCORE
+    }
+
+    operator fun compareTo(other: BlackjackScore): Int {
+        return this.value.compareTo(other.value)
+    }
+
+    companion object {
+        private const val BLACK_JACK_SCORE: Int = 21
+    }
+}

src/main/kotlin/blackjack/model/playable/Playable.kt

@@ -0,0 +1,14 @@
+package blackjack.model.playable
+
+import blackjack.model.BlackJackStatus
+import blackjack.model.pack.Pack
+import blackjack.model.playblestrategy.PlayingStrategy
+
+interface Playable {
+    fun score(): BlackjackScore
+    fun dealing(pack: Pack)
+    fun playing(playingStrategy: PlayingStrategy, pack: Pack): PlayableReaction
+    fun result(playable: Playable): PlayableResult
+    fun isBurst(): Boolean
+    fun status(): BlackJackStatus
+}

src/main/kotlin/blackjack/model/playable/PlayableReaction.kt

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