[STEP 4] 💣지뢰찾기💥 리팩터링

src/main/kotlin/tdd/minesweeper/Main.kt

@@ -0,0 +1,16 @@
+package tdd.minesweeper
+
+import tdd.minesweeper.ui.ConsoleInputView
+import tdd.minesweeper.ui.ConsoleOutputView
+import tdd.minesweeper.ui.MineSweeperApp
+import tdd.minesweeper.ui.RetryingInputView
+
+fun main() {
+    val app =
+        MineSweeperApp(
+            inputView = RetryingInputView(ConsoleInputView),
+            outputView = ConsoleOutputView,
+        )
+
+    app.play()
+}

src/main/kotlin/tdd/minesweeper/domain/AdjacentDirection.kt

@@ -0,0 +1,19 @@
+package tdd.minesweeper.domain
+
+enum class AdjacentDirection(val dr: Int, val dc: Int) {
+    TOP_LEFT(-1, -1),
+    TOP(-1, 0),
+    TOP_RIGHT(-1, 1),
+    LEFT(0, -1),
+    RIGHT(0, 1),
+    BOTTOM_LEFT(1, -1),
+    BOTTOM(1, 0),
+    BOTTOM_RIGHT(1, 1),
+    ;
+
+    companion object {
+        fun allAdjacentLocations(location: Location): List<Location> {
+            return entries.map { Location(location.row + it.dr, location.col + it.dc) }
+        }
+    }
+}

src/main/kotlin/tdd/minesweeper/domain/AdjacentMines.kt

@@ -0,0 +1,21 @@
+package tdd.minesweeper.domain
+
+@JvmInline
+value class AdjacentMines(private val value: Int) : Comparable<AdjacentMines> {
+    init {
+        require(value in MIN_VALUE..MAX_VALUE) {
+            "인접 지뢰 수는 $MIN_VALUE ~ $MAX_VALUE 만 허용한다: valuer=$value"
+        }
+    }
+
+    fun inc(): AdjacentMines {
+        return AdjacentMines(value + 1)
+    }
+
+    override operator fun compareTo(other: AdjacentMines): Int = value.compareTo(other.value)
+
+    companion object {
+        private const val MIN_VALUE = 0
+        private const val MAX_VALUE = 8
+    }
+}

src/main/kotlin/tdd/minesweeper/domain/Area.kt

@@ -0,0 +1,12 @@
+package tdd.minesweeper.domain
+
+data class Area(val height: Int, val width: Int) {
+    init {
+        require(height > 0) {
+            "높이는 양수여야 합니다: height=$height"
+        }
+        require(width > 0) {
+            "너비는 양수여야 합니다: width=$width"
+        }
+    }
+}

src/main/kotlin/tdd/minesweeper/domain/Board.kt

@@ -0,0 +1,37 @@
+package tdd.minesweeper.domain
+
+import tdd.minesweeper.domain.strategy.DefaultShouldOpenLocationFinder
+import tdd.minesweeper.domain.strategy.ShouldOpenLocationFinder
+
+data class Board(
+    val area: Area,
+    val cells: Cells,
+    private val shouldOpenLocationFinder: ShouldOpenLocationFinder = DefaultShouldOpenLocationFinder(),
+) {
+    fun countOfClosed(): Int = cells.count { !it.isOpen() }
+
+    fun countOfMineOpened(): Int = cells.count { it is MineCell }
+
+    fun open(location: Location): Board {
+        validateLocation(location)
+
+        val shouldOpen = shouldOpenLocationFinder.findAllShouldOpen(this, location)
+
+        return this.copy(cells = applyOpen(shouldOpen))
+    }
+
+    private fun validateLocation(location: Location) {
+        require(location.isValid(area)) {
+            "보드 내의 위치가 아닙니다: location=$location"
+        }
+    }
+
+    private fun applyOpen(shouldOpen: Set<Location>): Cells {
+        val shouldOpenIndexes = shouldOpen.map { it.toIndex(area.width) }.toSet()
+        val result = cells.toMutableList()
+
+        shouldOpenIndexes.forEach { index -> result[index] = cells[index].open() }
+
+        return Cells(result.toList())
+    }
+}

src/main/kotlin/tdd/minesweeper/domain/Cell.kt

@@ -0,0 +1,13 @@
+package tdd.minesweeper.domain
+
+interface Cell {
+    val adjacentMines: AdjacentMines?
+
+    fun isOpen(): Boolean
+
+    fun hasMine(): Boolean
+
+    fun open(): Cell
+
+    fun isExpandableToAdjacent(): Boolean
+}

src/main/kotlin/tdd/minesweeper/domain/Cells.kt

@@ -0,0 +1,4 @@
+package tdd.minesweeper.domain
+
+@JvmInline
+value class Cells(private val values: List<Cell>) : List<Cell> by values

src/main/kotlin/tdd/minesweeper/domain/ClosedCell.kt

@@ -0,0 +1,25 @@
+package tdd.minesweeper.domain
+
+data class ClosedCell(
+    private val hasMine: Boolean = false,
+    override val adjacentMines: AdjacentMines = AdjacentMines(0),
+) : Cell {
+    constructor(adjacentMines: Int) : this(adjacentMines = AdjacentMines(adjacentMines))
+
+    override fun isOpen(): Boolean = false
+
+    override fun hasMine(): Boolean = hasMine
+
+    override fun open(): Cell {
+        if (hasMine) {
+            return MineCell
+        }
+        return NumberCell(adjacentMines)
+    }
+
+    override fun isExpandableToAdjacent(): Boolean {
+        return !hasMine() && adjacentMines == AdjacentMines(0)
+    }
+
+    fun withAdjacentMines(newAdjacentMines: AdjacentMines): ClosedCell = this.copy(adjacentMines = newAdjacentMines)
+}

src/main/kotlin/tdd/minesweeper/domain/Game.kt

@@ -0,0 +1,35 @@
+package tdd.minesweeper.domain
+
+import tdd.minesweeper.domain.dsl.board
+
+class Game(private val countOfMines: Int, board: Board) {
+    var board = board
+        private set
+
+    fun open(location: Location) {
+        board = board.open(location)
+    }
+
+    fun state(): GameState =
+        when {
+            board.countOfMineOpened() > 0 -> GameState.LOSE
+            countOfMines == board.countOfClosed() -> GameState.WIN
+            else -> GameState.CONTINUE
+        }
+
+    companion object {
+        fun from(
+            height: Int,
+            width: Int,
+            countOfMines: Int,
+        ): Game {
+            val board =
+                board {
+                    height(height)
+                    width(width)
+                    countOfMines(countOfMines)
+                }
+            return Game(countOfMines, board)
+        }
+    }
+}

src/main/kotlin/tdd/minesweeper/domain/GameState.kt

@@ -0,0 +1,7 @@
+package tdd.minesweeper.domain
+
+enum class GameState {
+    WIN,
+    LOSE,
+    CONTINUE,
+}

src/main/kotlin/tdd/minesweeper/domain/Location.kt

@@ -0,0 +1,20 @@
+package tdd.minesweeper.domain
+
+data class Location(val row: Int, val col: Int) {
+    fun toIndex(width: Int): Int = (row - 1) * width + (col - 1)
+
+    fun isValid(area: Area): Boolean {
+        return row in 1..area.height && col in 1..area.width
+    }
+
+    companion object {
+        fun from(
+            index: Int,
+            width: Int,
+        ): Location =
+            Location(
+                row = (index / width) + 1,
+                col = (index % width) + 1,
+            )
+    }
+}

src/main/kotlin/tdd/minesweeper/domain/MineCell.kt

@@ -0,0 +1,13 @@
+package tdd.minesweeper.domain
+
+object MineCell : Cell {
+    override val adjacentMines: AdjacentMines? = null
+
+    override fun isOpen(): Boolean = true
+
+    override fun hasMine(): Boolean = true
+
+    override fun open(): Cell = this
+
+    override fun isExpandableToAdjacent(): Boolean = false
+}

src/main/kotlin/tdd/minesweeper/domain/NumberCell.kt

@@ -0,0 +1,11 @@
+package tdd.minesweeper.domain
+
+data class NumberCell(override val adjacentMines: AdjacentMines = AdjacentMines(0)) : Cell {
+    override fun isOpen(): Boolean = true
+
+    override fun hasMine(): Boolean = false
+
+    override fun open(): Cell = this
+
+    override fun isExpandableToAdjacent(): Boolean = false
+}

src/main/kotlin/tdd/minesweeper/domain/dsl/BoardBuilder.kt

@@ -0,0 +1,91 @@
+package tdd.minesweeper.domain.dsl
+
+import tdd.minesweeper.domain.Area
+import tdd.minesweeper.domain.Board
+import tdd.minesweeper.domain.Cells
+import tdd.minesweeper.domain.Location
+import tdd.minesweeper.domain.strategy.BoardCellsCreator
+import tdd.minesweeper.domain.strategy.DefaultBoardCellsCreator
+
+@BoardDslMaker
+class BoardBuilder(private val boardCellsCreator: BoardCellsCreator = DefaultBoardCellsCreator()) :
+    Builder<Board> {
+    private var height: Int = 0
+    private var width: Int = 0
+    private var countOfMines: Int = 0
+    private val manualMineLocations: MutableSet<Location> = mutableSetOf()
+    private val manualOpenLocations: MutableSet<Location> = mutableSetOf()
+
+    fun height(value: Int) =
+        apply {
+            require(value > 0) { "높이는 양수여야 합니다! input=$value" }
+            this.height = value
+        }
+
+    fun width(value: Int) =
+        apply {
+            require(value > 0) { "높이는 양수여야 합니다! input=$value" }
+            this.width = value
+        }
+
+    fun countOfMines(value: Int) = apply { this.countOfMines = value }
+
+    fun mineAt(
+        row: Int,
+        col: Int,
+    ) = apply { this.manualMineLocations.add(Location(row, col)) }
+
+    fun openAt(
+        row: Int,
+        col: Int,
+    ) = apply { this.manualOpenLocations.add(Location(row, col)) }
+
+    override fun build(): Board {
+        require(height > 0) { "높이는 양수여야 합니다! height=$height" }
+        require(width > 0) { "높이는 양수여야 합니다! width=$width" }
+        require(countOfMines <= width * height) { "최대 지뢰 개수는 모든 셀의 수입니다! max=${width * height}, countOfMines=$countOfMines" }
+
+        val area = Area(height = height, width = width)
+
+        val cells =
+            boardCellsCreator.createCells(
+                area = area,
+                countOfMines = countOfMines,
+                inputManualMineLocations = manualMineLocations.toSet(),
+            )
+
+        if (manualOpenLocations.isEmpty()) {
+            return Board(
+                area = area,
+                cells = cells,
+            )
+        }
+
+        val openedCells: Cells = openCellsManually(cells, area)
+
+        return Board(
+            area = area,
+            cells = openedCells,
+        )
+    }
+
+    private fun openCellsManually(
+        cells: Cells,
+        area: Area,
+    ): Cells {
+        return Cells(
+            cells.mapIndexed { index, cell ->
+                val location =
+                    Location.from(
+                        index = index,
+                        width = area.width,
+                    )
+                if (location in manualOpenLocations) {
+                    cell.open()
+                } else {
+                    cell
+                }
+            },
+        )
+    }
+}

src/main/kotlin/tdd/minesweeper/domain/dsl/BoardCreator.kt

@@ -0,0 +1,8 @@
+package tdd.minesweeper.domain.dsl
+
+import tdd.minesweeper.domain.Board
+
+@DslMarker
+annotation class BoardDslMaker
+
+fun board(block: BoardBuilder.() -> Unit): Board = BoardBuilder().apply(block).build()

src/main/kotlin/tdd/minesweeper/domain/dsl/Builder.kt

@@ -0,0 +1,5 @@
+package tdd.minesweeper.domain.dsl
+
+interface Builder<T> {
+    fun build(): T
+}

src/main/kotlin/tdd/minesweeper/domain/strategy/BoardCellsCreator.kt

@@ -0,0 +1,13 @@
+package tdd.minesweeper.domain.strategy
+
+import tdd.minesweeper.domain.Area
+import tdd.minesweeper.domain.Cells
+import tdd.minesweeper.domain.Location
+
+interface BoardCellsCreator {
+    fun createCells(
+        area: Area,
+        countOfMines: Int,
+        inputManualMineLocations: Set<Location>,
+    ): Cells
+}