🚀 4단계 - 지뢰 찾기(리팩터링) (#491)

* remove all

* docs: 요구사항 정리

* test: 사용자로부터 좌표를 입력받고 해당 입력을 검증한다.

* feat: 사용자로부터 좌표를 입력받고 해당 입력을 검증한다.

* test: `MineSweeperMetric`으로 `MineBoard`를 생성한다.

* rename: `MineSweeperMetric` 프로퍼티 네이밍 변경

* test: 각 셀은 좌표와 타입(`빈칸`, `지뢰칼`)정보를 갖는다.

* feat: 각 셀은 좌표와 타입(`빈칸`, `지뢰칼`)정보를 갖는다.

* refactor: MineBoard 프로퍼티를 일급 컬렉션으로 변경

* rename: 입력 메서드 네이밍 변경

* feat: 지뢰찾기 보드의 높이, 너비, 지뢰개수를 입력받는다.

* rename: 메서드 네이밍 변경

* feat: MineCells 생성 스켈레톤 코드

* test: MineCellGenerator 테스트코드 작성

* feat: RandomMineCellGenerator 구현

* refactor: 원시타입을 래핑한다.

* refactor: 일급컬렉션을 value class로 변경

* feat: MineBoard.cellsSize 구현

* feat: 셀은 open 또는 close 상태를 갖으며, 초기화된 시점의 모든 셀의 상태는 closed 이다.

* feat: 좌표 open 구현

* feat: 입력받은 좌표를 open 한다.

* test: 하나 이상의 MineCell이 Open 되어있는 경우 게임을 중단한다.

* feat: 사용자의 입력에 따라 게임을 속행 또는 중단한다.

* feat: MineBoard의 높이와 너비를 조회한다.

* feat: 좌표를 입력한 경우 인접한 EmptyCell을 함께 open한다.

* feat: 지뢰찾기 게임 진행 상황과 결과를 콘솔에 출력한다.

* test: getGameResult() 함수 테스트 추가

* docs: 문서 현행화

* fix: Model로 변환을 Controller 계층에서 수행하도록 변경한다.

* refactor: 셀의 상태 확인(open or closed)을 isOpened() 함수를 사용하도록 변경

* refactor: 보드의 높이와 너비 계산하는 함수를 읽기전용 프로퍼티를 사용하도록 변경

* test: `MineBoard.getCell()`, `MineBoard.openCell()` 테스트 추가

* fix: isOpen() 메서드 사용하도록 수정

* fix: execute의 결과를 List로 변경

Author: devtaebong

docs/step4.md

@@ -0,0 +1,20 @@
+# 🚀 4단계 - 지뢰 찾기(리팩터링)
+
+## 기능 요구사항
+
+- 기능 요구사항 3단계와 같다.
+- 추가로 제공되는 객체 설계 힌트를 참고해 철저하게 TDD로 재구현해 본다.
+
+### 기능 리스트
+
+- [x] 사용자로부터 좌표를 입력받는다.
+- [x] 입력받은 좌표 유효성 검사
+- [x] 각 셀은 좌표와 타입(`빈칸`, `지뢰칼`)정보를 갖는다.
+- [x] 지뢰 셀을 생성한다.
+- [x] MineSweeperMetric 으로 MineBoard 를 생성한다.
+- [x] 셀이 open된 셀인지, close된 셀인지에 대한 상태를 갖으며, 초기화된 시점은 모든 셀이 closed 상태이다.
+- [x] 하나 이상의 지뢰 셀을 열었으면 게임에서 패배한다.
+- [x] 모든 빈 셀을 열었으면 게임에서 승리한다.
+- [x] 입력한 셀에 지뢰가 없다면, 연결된 empty을 모두 Open
+- [x] close 된 셀은 C를 출력
+- [x] open 된 셀은 인접한 지뢰 개수를 출력

src/main/kotlin/.gitkeep

@@ -1,3 +1 @@
-import controller.MineSweeperController
-
-fun main() = MineSweeperController().run()
+fun main() = controller.MineSweeperController().run()

src/main/kotlin/MineSweeperApplication.kt

@@ -1,36 +1,61 @@
 package controller
 
 import domain.Cells
+import domain.Col
+import domain.Coordinate
 import domain.MineBoard
-import domain.MineGameMetric
 import domain.MineSweeperGame
+import domain.MineSweeperMetric
+import domain.Row
+import domain.strategy.MineCellGenerator
 import domain.strategy.RandomMineCellGenerator
 import view.InputView
 import view.OutputView
 
 class MineSweeperController {
     fun run() {
-        val rowSize = InputView.inputRowSize()
-        val colSize = InputView.inputColumnSize()
-        val mineCount = InputView.inputMineCount()
-        val mineGameMetric = MineGameMetric(boardHeightSize = rowSize, boardWidthSize = colSize, mineCount = mineCount)
+        val mineSweeperMetric = initializeMineSweeperMetric()
+        val mineCellGenerator: MineCellGenerator = RandomMineCellGenerator(mineSweeperMetric)
+        val cells = Cells.of(mineCellGenerator)
+        val mineBoard = MineBoard(cells)
 
-        val cells = Cells.generateWithMines(mineGameMetric, RandomMineCellGenerator())
-        val mineBoard = MineBoard(mineGameMetric, cells)
         OutputView.showMineSweeperBoard(mineBoard)
 
         gameLoop(mineBoard)
     }
 
+    private fun initializeMineSweeperMetric(): MineSweeperMetric {
+        val mineBoardHeight = InputView.inputMineBoardHeight()
+        val mineBoardWidth = InputView.inputMineBoardWidth()
+        val mineCount = InputView.inputMineCount()
+        return MineSweeperMetric(
+            mineBoardHeight = mineBoardHeight,
+            mineBoardWidth = mineBoardWidth,
+            mineCount = mineCount,
+        )
+    }
+
     private fun gameLoop(mineBoard: MineBoard) {
         val mineSweeperGame = MineSweeperGame(mineBoard)
         while (mineSweeperGame.isContinueGame()) {
-            val coordinate = InputView.askMineCoordinate()
-            mineSweeperGame.openAdjacentCell(coordinate)
+            val requestOpenCoordinate = parseToCoordinateOrThrow(InputView.askMineCoordinate())
+            mineSweeperGame.openAdjacentCell(requestOpenCoordinate)
             OutputView.showMineSweeperBoard(mineBoard)
         }
 
         val result = mineSweeperGame.getGameResult()
         OutputView.showGameResult(result)
     }
+
+    private fun parseToCoordinateOrThrow(value: String): Coordinate {
+        return value.replace(" ", "")
+            .split(",")
+            .also { require(it.size == 2) { INVALID_COORDINATE + value } }
+            .map { it.toIntOrNull() ?: throw IllegalArgumentException(INVALID_COORDINATE) }
+            .let { (row, col) -> Coordinate(Row(row), Col(col)) }
+    }
+
+    companion object {
+        private const val INVALID_COORDINATE = "두가지 숫자를 콤마(,)로 구분해서 입력해주세요 "
+    }
 }

src/main/kotlin/controller/MineSweeperController.kt

@@ -8,35 +8,35 @@ sealed interface Cell {
 
     fun open()
 
-    fun isAlreadyOpened(): Boolean {
+    fun isOpened(): Boolean {
         return status == CellStatus.OPEN
     }
 
-    data class MineCell(
+    class MineCell(
         override val coordinate: Coordinate,
         private var _status: CellStatus = CellStatus.CLOSED,
     ) : Cell {
         override val status: CellStatus
             get() = _status
 
+        override fun isMineCell(): Boolean = true
+
         override fun open() {
             _status = CellStatus.OPEN
         }
-
-        override fun isMineCell(): Boolean = true
     }
 
-    data class EmptyCell(
+    class EmptyCell(
         override val coordinate: Coordinate,
         private var _status: CellStatus = CellStatus.CLOSED,
     ) : Cell {
         override val status: CellStatus
             get() = _status
 
+        override fun isMineCell(): Boolean = false
+
         override fun open() {
             _status = CellStatus.OPEN
         }
-
-        override fun isMineCell(): Boolean = false
     }
 }

src/main/kotlin/domain/Cell.kt

@@ -1,89 +1,41 @@
 package domain
 
-import constants.MineSweeperConstants.MINIMUM_HEIGHT
-import constants.MineSweeperConstants.MINIMUM_WIDTH
-import domain.Cell.EmptyCell
-import domain.Cell.MineCell
 import domain.strategy.MineCellGenerator
 
 @JvmInline
-value class Cells(val cells: List<Cell>) {
-    fun mineCells(): List<Cell> = cells.filter { it.isMineCell() }.toList()
+value class Cells(private val cells: List<Cell>) {
+    val height: Row
+        get() = cells.maxBy { it.coordinate.row }.coordinate.row
+    val width: Col
+        get() = cells.maxBy { it.coordinate.col }.coordinate.col
+
+    fun numberOfTotalCells(): Int = cells.size
+
+    fun isAnyMineCellOpened(): Boolean {
+        return cells
+            .filter { it.isMineCell() }
+            .any { it.isOpened() }
+    }
 
-    fun emptyCells(): List<Cell> = cells.filter { it.isMineCell().not() }.toList()
+    fun isAllEmptyCellsOpened(): Boolean {
+        return cells
+            .filter { it.isMineCell().not() }
+            .all { it.isOpened() }
+    }
 
     fun get(coordinate: Coordinate): Cell {
         return cells.firstOrNull { it.coordinate == coordinate }
             ?: throw NoSuchElementException("Coordinate $coordinate not found")
     }
 
-    fun countOpenedMineCells(): Int {
-        return mineCells().count { it.status == CellStatus.OPEN }
-    }
-
-    fun countOpenedEmptyCells(): Int {
-        return emptyCells().count { it.status == CellStatus.OPEN }
-    }
-
-    fun countEmptyCells(): Int {
-        return emptyCells().size
-    }
-
-    fun isAllEmptyCellsOpened(): Boolean {
-        val openedEmptyCellCount = countOpenedEmptyCells()
-        val totalEmptyCellCount = countEmptyCells()
-
-        return openedEmptyCellCount == totalEmptyCellCount
+    fun groupByRow(): Map<Row, List<Cell>> {
+        return cells.groupBy { it.coordinate.row }
     }
 
     companion object {
-        fun generateWithMines(
-            mineGameMetric: MineGameMetric,
-            mineCellGenerator: MineCellGenerator,
-        ): Cells {
-            val emptyCellCoordinates = generateEmptyCells(mineGameMetric.boardHeightSize, mineGameMetric.boardWidthSize)
-            val mineCellCoordinates =
-                generateMineCells(
-                    mineCellGenerator,
-                    mineGameMetric,
-                )
-
-            val cells = emptyCellCoordinates.map { coordinate -> parseCell(mineCellCoordinates, coordinate) }
-            return Cells(cells)
-        }
-
-        private fun generateEmptyCells(
-            mineBoardHeightSize: Int,
-            mineBoardWidthSize: Int,
-        ): List<Coordinate> {
-            val heightRange = MINIMUM_HEIGHT..mineBoardHeightSize
-            val widthRange = MINIMUM_WIDTH..mineBoardWidthSize
-
-            return heightRange.flatMap { height ->
-                widthRange.map { width ->
-                    Coordinate(height, width)
-                }
-            }
-        }
-
-        private fun generateMineCells(
-            mineCellGenerator: MineCellGenerator,
-            mineGameMetric: MineGameMetric,
-        ): Set<Coordinate> {
-            val mineCell = mineCellGenerator.execute(mineGameMetric)
-            return mineCell
-                .map { it.coordinate }
-                .toSet()
-        }
-
-        private fun parseCell(
-            mineCoordinates: Set<Coordinate>,
-            coordinate: Coordinate,
-        ): Cell {
-            if (coordinate in mineCoordinates) {
-                return MineCell(coordinate)
-            }
-            return EmptyCell(coordinate)
+        fun of(mineCellGenerator: MineCellGenerator): Cells {
+            val mineCells = mineCellGenerator.execute()
+            return Cells(mineCells.toList())
         }
     }
 }

src/main/kotlin/domain/Cells.kt

@@ -1,8 +1,12 @@
 package domain
 
 @JvmInline
-value class Col(val value: Int) {
-    operator fun plus(other: Int): Col = Col(value + other)
+value class Col(private val value: Int) : Comparable<Col> {
+    override fun compareTo(other: Col): Int {
+        return this.value.compareTo(other.value)
+    }
 
-    operator fun compareTo(other: Col): Int = value.compareTo(other.value)
+    operator fun plus(other: Col): Col {
+        return Col(this.value + other.value)
+    }
 }

src/main/kotlin/domain/Col.kt

@@ -2,13 +2,15 @@ package domain
 
 data class Coordinate(val row: Row, val col: Col) {
     operator fun plus(offset: Coordinate): Coordinate {
-        return Coordinate(row + offset.row.value, col + offset.col.value)
+        return Coordinate(row + offset.row, col + offset.col)
     }
 
     companion object {
         operator fun invoke(
             row: Int,
             col: Int,
-        ) = Coordinate(Row(row), Col(col))
+        ): Coordinate {
+            return Coordinate(Row(row), Col(col))
+        }
     }
 }

src/main/kotlin/domain/Coordinate.kt

@@ -1,12 +1,12 @@
 package domain
 
 enum class Direction(val offset: Coordinate) {
-    NORTH(Coordinate(Row(-1), Col(0))),
-    SOUTH(Coordinate(Row(1), Col(0))),
-    WEST(Coordinate(Row(0), Col(-1))),
-    EAST(Coordinate(Row(0), Col(1))),
-    NORTH_WEST(Coordinate(Row(-1), Col(-1))),
-    NORTH_EAST(Coordinate(Row(-1), Col(1))),
-    SOUTH_WEST(Coordinate(Row(1), Col(-1))),
-    SOUTH_EAST(Coordinate(Row(1), Col(1))),
+    NORTH(Coordinate(-1, 0)),
+    SOUTH(Coordinate(1, 0)),
+    WEST(Coordinate(0, -1)),
+    EAST(Coordinate(0, 1)),
+    NORTH_WEST(Coordinate(-1, -1)),
+    NORTH_EAST(Coordinate(-1, 1)),
+    SOUTH_WEST(Coordinate(1, -1)),
+    SOUTH_EAST(Coordinate(1, 1)),
 }

src/main/kotlin/domain/Direction.kt

@@ -1,15 +1,29 @@
 package domain
 
-class MineBoard(
-    private val mineGameMetric: MineGameMetric,
-    val cells: Cells,
-) {
+import constants.MineSweeperConstants.MINIMUM_HEIGHT
+import constants.MineSweeperConstants.MINIMUM_WIDTH
+
+class MineBoard(private val cells: Cells) {
+    fun cellsSize() = cells.numberOfTotalCells()
+
+    fun hasMineExploded(): Boolean {
+        return cells.isAnyMineCellOpened()
+    }
+
+    fun isCleared(): Boolean {
+        return cells.isAllEmptyCellsOpened()
+    }
+
+    fun getCell(coordinate: Coordinate): Cell = cells.get(coordinate)
+
+    fun openCell(coordinate: Coordinate) = cells.get(coordinate).open()
+
     fun countAdjacentMines(cell: Cell): Int {
         var numberOfMines = 0
 
         for (direction in Direction.entries) {
             val nextCoordinate = cell.coordinate + direction.offset
-            if (mineGameMetric.isOutOfMineBoard(nextCoordinate)) {
+            if (isOutOfMineBoard(nextCoordinate)) {
                 continue
             }
 
@@ -25,29 +39,22 @@ class MineBoard(
 
         for (direction in Direction.entries) {
             val nextCoordinate = cell.coordinate + direction.offset
-            if (!mineGameMetric.isOutOfMineBoard(nextCoordinate)) {
+            if (!isOutOfMineBoard(nextCoordinate)) {
                 adjacentCoordinates.add(nextCoordinate)
             }
         }
 
         return adjacentCoordinates
     }
 
-    fun isMineCell(coordinate: Coordinate): Boolean {
-        return cells.get(coordinate).isMineCell()
-    }
-
-    fun isAnyMineCellOpened(): Boolean {
-        return cells.countOpenedMineCells() > 0
+    private fun isOutOfMineBoard(coordinate: Coordinate): Boolean {
+        return (
+            Row(MINIMUM_HEIGHT) <= coordinate.row && coordinate.row <= cells.height &&
+                Col(MINIMUM_WIDTH) <= coordinate.col && coordinate.col <= cells.width
+        ).not()
     }
 
-    fun isAllEmptyCellsOpened(): Boolean {
-        return cells.isAllEmptyCellsOpened()
+    fun cellsByRow(): Map<Row, List<Cell>> {
+        return cells.groupByRow()
     }
-
-    fun openCell(coordinate: Coordinate) {
-        cells.get(coordinate).open()
-    }
-
-    fun getCell(current: Coordinate): Cell = cells.get(current)
 }