Step2

README.md

@@ -1 +1,25 @@
-# kotlin-blackjack
+# kotlin-blackjack
+# Step2
+- 기능 목록
+  - 도메인
+    - 카드
+      - 숫자와 문양을 결합한 문자열을 반환
+      - 숫자에 맞는 점수 리스트를 반환
+        - 카드 A의 경우 1, 11의 점수를 가짐
+        - 카드 K, Q, J의 경우 10의 점수를 가짐
+    - 카드 풀
+      - 랜덤한 카드 한 장을 반환
+        - 카드 풀에서 반환한 카드 제거
+    - 플레이어
+      - 보유한 카드 점수 합 리스트를 반환
+      - 추가 카드를 뽑을 수 있는 점수 합인지 검증
+    - 블랙잭 게임
+      - 플레이어들을 전달 받고 블랙잭 게임 반환
+      - 각 개별 플레이어들 블랙젝 게임 실행
+  - 입력
+    - 참가하는 플레이어의 이름을 입력받음
+      - 플레이어들의 이름 문자열이 콤마(,)로 구분되는지 검사
+    - 플레이어가 카드를 더 뽑을지 말지를 Y/N으로 입력
+      - 입력받는 값이 Y/N인지 검증
+  - 출력
+    - 플레이어의 이름, 보유 카드 및 플레이어의 점수 출력 

src/main/kotlin/blackjack/BlackjackApplication.kt

@@ -0,0 +1,48 @@
+package blackjack
+
+import blackjack.contoller.BlackjackController
+import blackjack.domain.component.BlackjackGameProxy
+import blackjack.domain.component.BlackjackInputValidator
+import blackjack.domain.model.PlayerName
+import blackjack.view.BlackjackInputView
+import blackjack.view.BlackjackResultView
+
+fun main() {
+    val controller = init()
+
+    process(controller)
+}
+
+private fun init(): BlackjackController {
+    return BlackjackController(
+        BlackjackInputView(),
+        BlackjackInputValidator(),
+        BlackjackResultView(),
+        BlackjackGameProxy()
+    )
+}
+
+private fun process(blackjackController: BlackjackController) {
+    val playerNames: List<PlayerName> = blackjackController.getPlayerNames()
+
+    blackjackController.initGame(playerNames)
+    blackjackController.printInitialGameStatus()
+
+    playerNames.forEach {
+        it.play(blackjackController)
+    }
+
+    blackjackController.printGameResultStatus()
+}
+
+private fun PlayerName.play(blackjackController: BlackjackController) {
+    while (blackjackController.getHitPossible(this)) {
+        if (blackjackController.getHit(this).isNo()) {
+            return
+        }
+
+        val player = blackjackController.hit(this)
+
+        blackjackController.printPlayerInfo(player)
+    }
+}

src/main/kotlin/blackjack/contoller/BlackjackController.kt

@@ -0,0 +1,90 @@
+package blackjack.contoller
+
+import blackjack.domain.component.BlackjackGameProxy
+import blackjack.domain.component.BlackjackInputValidator
+import blackjack.domain.model.Player
+import blackjack.domain.model.PlayerInfo
+import blackjack.domain.model.PlayerName
+import blackjack.domain.model.YesNo
+import blackjack.view.BlackjackInputView
+import blackjack.view.BlackjackResultView
+
+class BlackjackController(
+    private val blackJackInputView: BlackjackInputView,
+    private val blackjackInputValidator: BlackjackInputValidator,
+    private val blackjackResultView: BlackjackResultView,
+    private val blackjackGameProxy: BlackjackGameProxy
+) {
+    fun getPlayerNames(): List<PlayerName> {
+        val playerNamesString: String? = blackJackInputView.getPlayerNames()
+
+        return convertPlayerNamesStringToList(playerNamesString)
+    }
+
+    fun getHitPossible(playerName: PlayerName): Boolean {
+        return blackjackGameProxy.isHitPossible(playerName)
+    }
+
+    fun getHit(playerName: PlayerName): YesNo {
+        return blackJackInputView
+            .getHit(playerName.name)
+            .run { convertYesNo(this) }
+    }
+
+    fun initGame(playerNames: List<PlayerName>) {
+        blackjackGameProxy.init(playerNames)
+    }
+
+    fun hit(playerName: PlayerName): Player {
+        return blackjackGameProxy.hit(playerName)
+    }
+
+    fun printInitialGameStatus() {
+        blackjackGameProxy
+            .fetchPlayerInfos()
+            .run { blackjackResultView.printGameInitialStatus(this) }
+    }
+
+    fun printGameResultStatus() {
+        blackjackGameProxy
+            .fetchPlayerInfos()
+            .run { blackjackResultView.printGameResultStatus(this) }
+    }
+
+    fun printPlayerInfos() {
+        blackjackGameProxy
+            .fetchPlayerInfos()
+            .run { blackjackResultView.printPlayerInfos(this) }
+    }
+
+    fun printPlayerInfo(player: Player) {
+        val playerInfo = PlayerInfo.from(player)
+
+        blackjackResultView.printPlayerInfo(playerInfo, false)
+    }
+
+    private fun convertPlayerNamesStringToList(playerNames: String?): List<PlayerName> {
+        return playerNames
+            .run { blackjackInputValidator.validatePlayerNamesString(this) }
+            .split(PLAYER_NAME_SEPARATOR)
+            .run { blackjackInputValidator.validatePlayerNamesSize(this) }
+            .map { PlayerName(it) }
+    }
+
+    private fun convertYesNo(yesNo: String?): YesNo {
+        return yesNo
+            .run { blackjackInputValidator.validateYesNoString(this) }
+            .run { YesNo.from(this) ?: YesNo.N }
+    }
+
+    private fun BlackjackGameProxy.fetchPlayerInfos(): List<PlayerInfo> {
+        return this
+            .getPlayers()
+            .players
+            .map { PlayerInfo.from(it) }
+    }
+
+    companion object {
+        private const val PLAYER_NAME_SEPARATOR = ","
+    }
+}

src/main/kotlin/blackjack/domain/component/BlackjackGame.kt

@@ -0,0 +1,49 @@
+package blackjack.domain.component
+
+import blackjack.domain.model.*
+
+class BlackjackGame private constructor(
+    val players: Players,
+    private val cardPool: CardPool
+) {
+    fun isHitPossible(playerName: PlayerName): Boolean {
+        return players
+            .findByName(playerName)
+            .checkNull()
+            .isPossibleToHit()
+    }
+
+    fun hit(playerName: PlayerName): Player {
+        val player = players.findByName(playerName)
+        val card = cardPool.pickAndRemove()
+
+        return player
+            .checkNull()
+            .append(card)
+    }
+
+    private fun Player?.checkNull(): Player {
+        check(this != null) { "해당 플레이어는 존재하지 않습니다." }
+
+        return this
+    }
+
+    companion object {
+        const val INITIAL_CARD_COUNT = 2
+
+        fun create(playerNames: List<PlayerName>): BlackjackGame {
+            val cardPool = CardPool.create()
+            val players = playerNames
+                .map { Player(it, fetchInitialCards(cardPool)) }
+                .run { Players(this) }
+
+            return BlackjackGame(players, cardPool)
+        }
+
+        private fun fetchInitialCards(cardPool: CardPool): Cards {
+            return cardPool
+                .pickAndRemove(INITIAL_CARD_COUNT)
+                .run { Cards.of(this) }
+        }
+    }
+}

src/main/kotlin/blackjack/domain/component/BlackjackGameProxy.kt

@@ -0,0 +1,37 @@
+package blackjack.domain.component
+
+import blackjack.domain.model.Player
+import blackjack.domain.model.PlayerName
+import blackjack.domain.model.Players
+
+class BlackjackGameProxy(
+    private var blackjackGame: BlackjackGame? = null
+) {
+    fun init(playerNames: List<PlayerName>) {
+        blackjackGame = BlackjackGame.create(playerNames)
+    }
+
+    fun isHitPossible(playerName: PlayerName): Boolean {
+        return blackjackGame
+            .checkGameExist()
+            .isHitPossible(playerName)
+    }
+
+    fun hit(playerName: PlayerName): Player {
+        return blackjackGame
+            .checkGameExist()
+            .hit(playerName)
+    }
+
+    fun getPlayers(): Players {
+        return blackjackGame
+            .checkGameExist()
+            .players
+    }
+
+    private fun BlackjackGame?.checkGameExist(): BlackjackGame {
+        check(this != null) { "게임이 존재하지 않습니다." }
+
+        return this
+    }
+}

src/main/kotlin/blackjack/domain/component/BlackjackInputValidator.kt

@@ -0,0 +1,21 @@
+package blackjack.domain.component
+
+class BlackjackInputValidator {
+    fun validatePlayerNamesString(playerNames: String?): String {
+        require(!playerNames.isNullOrBlank()) { "플레이어 이름은 null 또는 공백일 수 없습니다." }
+
+        return playerNames
+    }
+
+    fun validatePlayerNamesSize(playerNames: List<String>): List<String> {
+        require(playerNames.isNotEmpty()) { "게임에는 1명 이상의 플레이어가 참가해야합니다." }
+
+        return playerNames
+    }
+
+    fun validateYesNoString(yesNo: String?): String {
+        require(!yesNo.isNullOrBlank()) { "힛은 null 또는 공백일 수 없습니다." }
+
+        return yesNo
+    }
+}

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

@@ -0,0 +1,24 @@
+package blackjack.domain.model
+
+class Card private constructor(
+    val number: CardNumber,
+    val shape: CardShape,
+    val scores: List<Score>
+) {
+    companion object {
+        private val CARD_ACE_SCORES = listOf(Score(1), Score(11))
+        private val CARD_KQJ_SCORES = listOf(Score(10))
+
+        fun of(number: CardNumber, shape: CardShape): Card {
+            if (number.isAce()) {
+                return Card(number, shape, CARD_ACE_SCORES)
+            }
+
+            if (number.isOneOfKQJ()) {
+                return Card(number, shape, CARD_KQJ_SCORES)
+            }
+
+            return Card(number, shape, listOf(Score(number.number)))
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+package blackjack.domain.model
+
+enum class CardNumber(val number: Int, val displayName: String) {
+    ACE(1, "A"),
+    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(11, "J"),
+    QUEEN(12, "Q"),
+    KING(13, "K"),
+    ;
+
+    fun isAce(): Boolean {
+        return number == 1
+    }
+
+    fun isOneOfKQJ(): Boolean {
+        return number >= 11
+    }
+}

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

@@ -0,0 +1,25 @@
+package blackjack.domain.model
+
+class CardPool private constructor(private var cards: MutableList<Card>) {
+    fun pickAndRemove(): Card {
+        check(cards.size > 0) { "카드 풀의 카드가 존재하지 않습니다." }
+
+        val target = (0 until cards.size).random()
+
+        return cards.removeAt(target)
+    }
+
+    fun pickAndRemove(count: Int): List<Card> {
+        if (count < 0) {
+            return listOf()
+        }
+
+        return (0 until count).map { pickAndRemove() }
+    }
+
+    companion object {
+        fun create(): CardPool {
+            return CardPool(Cards.create().cards.toMutableList())
+        }
+    }
+}

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

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