🚀 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,40 @@
 package blackjack
 
+import blackjack.model.DealerStrategy
 import blackjack.model.Participants
+import blackjack.model.PlayableReaction
 import blackjack.model.Player
+import blackjack.model.Referee
+import blackjack.model.pack.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)
+    OutputView.presentScores(participants)
+    OutputView.presentResult(Referee.blackJackResult(participants))
 }
 
 fun playingBlackJack(participants: Participants) {
-    participants.participants.forEach {
-        it.hitOrStand()
+    participants.players.values.forEach {
+        it.playing(InputView.askHit(it), ShuffledPack)
+    }
+    when (participants.dealer.playing(DealerStrategy(participants.dealer.score()), ShuffledPack)) {
+        PlayableReaction.HIT -> println("딜러는 16이하라 한장의 카드를 더 받았습니다.")
+        PlayableReaction.STAND -> println("딜러는 17이상이라 카드를 받지 않았습니다.")
     }
 }
 
 private fun Player.hitOrStand() {
-    if (InputView.askHit(this)) {
-        this.hit()
-    }
-    OutputView.playerCardPresent(this)
+
+//    if () {
+//        this.hit(ShuffledPack)
+//    }
+//    OutputView.playerCardPresent(this)
 }

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

@@ -5,16 +5,16 @@ class Card private constructor(
     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(this.CARDS[Trump(suit to cardRank)]) { "입력된 suit=[$suit] , cardRank=[$cardRank] 는 찾을수 없습니다" }
         }
     }
 }

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

@@ -28,10 +28,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 +40,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/Dealer.kt

@@ -0,0 +1,33 @@
+package blackjack.model
+
+import blackjack.model.pack.Pack
+
+class Dealer(
+    val cards: Cards = Cards(),
+) : Playable {
+
+    override fun score(): Int {
+        return cards.totalScore()
+    }
+
+    override fun dealing(pack: Pack) {
+        this.cards.add(pack.pickCard())
+        this.cards.add(pack.pickCard())
+    }
+
+    fun countOfCards(): Int {
+        return cards.count()
+    }
+
+    override fun playing(playingStrategy: PlayingStrategy, pack: Pack): PlayableReaction {
+        if (playingStrategy.isHit()) {
+            cards.add(pack.pickCard())
+            return PlayableReaction.HIT
+        }
+        return PlayableReaction.STAND
+    }
+
+    companion object {
+        private const val DEALER_PICK_THRESHOLD = 16
+    }
+}

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

@@ -0,0 +1,8 @@
+package blackjack.model
+
+data class DealerResult(
+    val point: Int,
+    val winning: Int,
+    val drawing: Int,
+    val losing: Int,
+)

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

@@ -0,0 +1,14 @@
+package blackjack.model
+
+class DealerStrategy(
+    private val currentScore: Int,
+) : PlayingStrategy {
+
+    override fun isHit(): Boolean {
+        return currentScore <= DEALER_PICK_THRESHOLD
+    }
+
+    companion object {
+        private const val DEALER_PICK_THRESHOLD = 16
+    }
+}

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

@@ -0,0 +1,31 @@
+package blackjack.model
+
+class ParticipantResults(
+    val playerResults: PlayersResults,
+    val dealerDealerResult: Pair<Dealer, DealerResult>,
+) {
+    fun dealerResult(): DealerResult {
+        return dealerDealerResult.second
+    }
+
+    fun playerResult(player: Player): PlayerResult {
+        return playerResults.resultOfPlayer(player)
+    }
+
+    fun dealerWinCount(): Int {
+        return this.dealerDealerResult.second.winning
+    }
+
+    fun dealerLoseCount(): Int {
+        return this.dealerDealerResult.second.losing
+    }
+
+    companion object {
+        fun ofDealerLose(participants: Participants): ParticipantResults {
+            return ParticipantResults(
+                PlayersResults(participants.players.walkover()),
+                participants.dealer to DealerResult(participants.dealer.score(), 0, 0, participants.count() - 1)
+            )
+        }
+    }
+}

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

@@ -1,21 +1,26 @@
 package blackjack.model
 
+import blackjack.model.pack.Pack
+
 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) }
+        return players.isGameOver() || Referee.isGameOver(dealer)
     }
 
     fun isContinue(): Boolean {
         return !isGameOver()
     }
+
+    fun count(): Int {
+        return players.count() + 1
+    }
 }

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

@@ -0,0 +1,9 @@
+package blackjack.model
+
+import blackjack.model.pack.Pack
+
+interface Playable {
+    fun score(): Int
+    fun dealing(pack: Pack)
+    fun playing(playingStrategy: PlayingStrategy, pack: Pack): PlayableReaction
+}

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

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

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

@@ -1,17 +1,29 @@
 package blackjack.model
 
-import blackjack.model.pack.ShuffledPack
+import blackjack.model.pack.Pack
 
-data class Player(
+class Player(
     val name: String,
     val cards: Cards = Cards.emptyCards(),
-) {
-    fun deal() {
-        cards.add(ShuffledPack.pickCard())
-        cards.add(ShuffledPack.pickCard())
+) : Playable {
+    override fun dealing(pack: Pack) {
+        cards.add(pack.pickCard())
+        cards.add(pack.pickCard())
     }
 
-    fun hit() {
-        cards.add(ShuffledPack.pickCard())
+    override fun playing(playingStrategy: PlayingStrategy, pack: Pack): PlayableReaction {
+        if (playingStrategy.isHit()) {
+            this.hit(pack)
+            return PlayableReaction.HIT
+        }
+        return PlayableReaction.STAND
+    }
+
+    fun hit(pack: Pack) {
+        cards.add(pack.pickCard())
+    }
+
+    override fun score(): Int {
+        return this.cards.totalScore()
     }
 }

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

@@ -0,0 +1,7 @@
+package blackjack.model
+
+enum class PlayerResult {
+    WIN,
+    LOSE,
+    DRAW,
+}

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

@@ -0,0 +1,33 @@
+package blackjack.model
+
+import blackjack.model.pack.Pack
+
+class Players(
+    val values: Set<Player>,
+) {
+    constructor(vararg players: Player) : this(players.toSet())
+
+    fun dealing(pack: Pack) {
+        values.forEach { it.dealing(pack) }
+    }
+
+    fun isGameOver(): Boolean {
+        return values.any { Referee.isGameOver(it) }
+    }
+
+    fun count(): Int {
+        return values.size
+    }
+
+    fun scoreBattle(dealerScore: Int): Map<Player, PlayerResult> {
+        return values.associateWith { Referee.playerResult(it, dealerScore) }
+    }
+
+    fun walkover(): Map<Player, PlayerResult> {
+        return values.associateWith { PlayerResult.WIN }
+    }
+
+    init {
+        require(values.map { it.name }.distinct().size == values.size) { "Player 들의 이름은 중복이 허용되지 않습니다" }
+    }
+}

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

@@ -0,0 +1,29 @@
+package blackjack.model
+
+class PlayersResults(
+    private val value: Map<Player, PlayerResult>,
+) {
+    fun loseCount(): Int {
+        return value.values.count { it == PlayerResult.LOSE }
+    }
+
+    fun winningCount(): Int {
+        return value.values.count { it == PlayerResult.WIN }
+    }
+
+    fun drawingCount(): Int {
+        return value.values.count { it == PlayerResult.DRAW }
+    }
+
+    fun resultOfPlayer(player: Player): PlayerResult {
+        return requireNotNull(value[player]) { "플레이어를 찾을 수 없음" }
+    }
+
+    fun playerResult(): List<Pair<String, PlayerResult>> {
+        return value.keys.map { playerNameAndResult(it) }.toList()
+    }
+
+    private fun playerNameAndResult(it: Player): Pair<String, PlayerResult> {
+        return it.name to requireNotNull(value[it]) { "플레이어 ${it.name} 을 찾을 수 없습니다" }
+    }
+}

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

@@ -0,0 +1,5 @@
+package blackjack.model
+
+interface PlayingStrategy {
+    fun isHit(): Boolean
+}