🚀 3단계 - 지뢰 찾기(게임 실행) (#480)

* rename: findCellByCoordinate 함수 네이밍 수정

* refactor: 메서드 체이닝을 변수로 추출하고, 한줄에 하나의 메서드 호출만 하도록 수정

* refactor: Coordinate(height, width)로도 Coordinate 객체를 생성할 수 있는 코드 제공

* docs: 요구사항 정리

* feat: 사용자로부터 좌표를 입력받는다.

* feat: 셀이 open된 셀인지, close된 셀인지에 대한 상태를 갖는다.

* feat: 게임 승리 or 패배 스켈레톤 코드

* rename: 테스트 클래스 네이밍 수정

* test: 게임 승리 or 패배 테스트코드 작성

* feat: 하나 이상의 지뢰 셀을 열었으면 게임에서 패배한다.

* test: open 되어 있는 지뢰셀과 비어있는 셀의 개수를 센다.

* feat: 모든 빈 셀을 열었으면 게임에서 승리한다.

* test: 지뢰 셀을 open 하지 않았고, 비어있는 모든 칸을 open 하지 않은 경우 게임을 계속한다.

* refactor: isContinueGame 함수 when 식으로 변경

* feat: 입력받은 좌표에 해당하는 셀을 오픈한다.

* feat: 입력한 셀에 지뢰가 없다면, 연결된 empty을 모두 Open

* feat: 입력한 셀에 지뢰가 없다면, 연결된 empty을 모두 Open

* refactor: dfs -> bfs 변경 및 메서드 추출

* test: getAdjacentCoordinates 함수 테스트

* fix: isContinueGame() 함수에서 GameResult에 대한 관심사를 분리한다.

* fix: MineSweeperGame 객체 GameResult에 대한 상태를 제거한다.

* feat: 게임 결과를 조회한다.

* fix: mineCell도 오픈할 수 있도록 변경

* fix: compareTo 제거

* fix: Cell 타입을 구분할 수 있는 메서드를 통해 지뢰셀과 비어있는 셀을 필터링

* fix: showMineSweeperBoard 그룹핑을 row(원시값) -> Row(래핑 클래스)로 변경

* refactor: shouldSkipCell() 메서드를 제거하고 cell 에게 메세지를 보내는 구조로 변경

* refactor: isAllEmptyCellsOpened() 함수를 cells 에게 메세지를 보내는 구조로 변경

Author: devtaebong

docs/step3.md

@@ -0,0 +1,19 @@
+# 🚀 3단계 - 지뢰 찾기(게임 실행)
+
+## 기능 요구사항
+
+- 높이와 너비, 지뢰 개수를 입력받을 수 있다.
+- 지뢰는 눈에 잘 띄는 것으로 표기한다.
+- 지뢰는 가급적 랜덤에 가깝게 배치한다.
+- 각 사각형에 표시될 숫자는 자신을 제외한 주변 8개 사각형에 포함된 지뢰의 개수다.
+- 지뢰가 없는 인접한 칸이 모두 열리게 된다.
+
+### 기능 리스트
+
+- [x] 사용자로부터 좌표를 입력받는다.
+- [x] 셀이 open된 셀인지, close된 셀인지에 대한 상태를 갖는다.
+- [x] 하나 이상의 지뢰 셀을 열었으면 게임에서 패배한다.
+- [x] 모든 빈 셀을 열었으면 게임에서 승리한다.
+- [x] 입력한 셀에 지뢰가 없다면, 연결된 empty을 모두 Open
+- [x] close 된 셀은 C를 출력
+- [x] open 된 셀은 인접한 지뢰 개수를 출력

src/main/kotlin/controller/MineSweeperController.kt

@@ -3,6 +3,7 @@ package controller
 import domain.Cells
 import domain.MineBoard
 import domain.MineGameMetric
+import domain.MineSweeperGame
 import domain.strategy.RandomMineCellGenerator
 import view.InputView
 import view.OutputView
@@ -16,7 +17,20 @@ class MineSweeperController {
 
         val cells = Cells.generateWithMines(mineGameMetric, RandomMineCellGenerator())
         val mineBoard = MineBoard(mineGameMetric, cells)
-
         OutputView.showMineSweeperBoard(mineBoard)
+
+        gameLoop(mineBoard)
+    }
+
+    private fun gameLoop(mineBoard: MineBoard) {
+        val mineSweeperGame = MineSweeperGame(mineBoard)
+        while (mineSweeperGame.isContinueGame()) {
+            val coordinate = InputView.askMineCoordinate()
+            mineSweeperGame.openAdjacentCell(coordinate)
+            OutputView.showMineSweeperBoard(mineBoard)
+        }
+
+        val result = mineSweeperGame.getGameResult()
+        OutputView.showGameResult(result)
     }
 }

src/main/kotlin/domain/Cell.kt

@@ -2,12 +2,41 @@ package domain
 
 sealed interface Cell {
     val coordinate: Coordinate
+    val status: CellStatus
 
-    fun isMineCell(): Boolean {
-        return this is MineCell
+    fun isMineCell(): Boolean
+
+    fun open()
+
+    fun isAlreadyOpened(): Boolean {
+        return status == CellStatus.OPEN
+    }
+
+    data class MineCell(
+        override val coordinate: Coordinate,
+        private var _status: CellStatus = CellStatus.CLOSED,
+    ) : Cell {
+        override val status: CellStatus
+            get() = _status
+
+        override fun open() {
+            _status = CellStatus.OPEN
+        }
+
+        override fun isMineCell(): Boolean = true
     }
 
-    data class MineCell(override val coordinate: Coordinate) : Cell
+    data class EmptyCell(
+        override val coordinate: Coordinate,
+        private var _status: CellStatus = CellStatus.CLOSED,
+    ) : Cell {
+        override val status: CellStatus
+            get() = _status
 
-    data class EmptyCell(override val coordinate: Coordinate) : Cell
+        override fun open() {
+            _status = CellStatus.OPEN
+        }
+
+        override fun isMineCell(): Boolean = false
+    }
 }

src/main/kotlin/domain/CellStatus.kt

@@ -0,0 +1,6 @@
+package domain
+
+enum class CellStatus {
+    OPEN,
+    CLOSED,
+}

src/main/kotlin/domain/Cells.kt

@@ -8,15 +8,34 @@ import domain.strategy.MineCellGenerator
 
 @JvmInline
 value class Cells(val cells: List<Cell>) {
-    fun mineCells(): List<MineCell> = cells.filterIsInstance<MineCell>()
+    fun mineCells(): List<Cell> = cells.filter { it.isMineCell() }.toList()
 
-    fun emptyCells(): List<EmptyCell> = cells.filterIsInstance<EmptyCell>()
+    fun emptyCells(): List<Cell> = cells.filter { it.isMineCell().not() }.toList()
 
-    fun getCoordinateIs(coordinate: Coordinate): Cell {
+    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
+    }
+
     companion object {
         fun generateWithMines(
             mineGameMetric: MineGameMetric,
@@ -42,7 +61,7 @@ value class Cells(val cells: List<Cell>) {
 
             return heightRange.flatMap { height ->
                 widthRange.map { width ->
-                    Coordinate(Row(height), Col(width))
+                    Coordinate(height, width)
                 }
             }
         }
@@ -51,7 +70,10 @@ value class Cells(val cells: List<Cell>) {
             mineCellGenerator: MineCellGenerator,
             mineGameMetric: MineGameMetric,
         ): Set<Coordinate> {
-            return mineCellGenerator.execute(mineGameMetric).map { it.coordinate }.toSet()
+            val mineCell = mineCellGenerator.execute(mineGameMetric)
+            return mineCell
+                .map { it.coordinate }
+                .toSet()
         }
 
         private fun parseCell(

src/main/kotlin/domain/Coordinate.kt

@@ -4,4 +4,11 @@ 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)
     }
+
+    companion object {
+        operator fun invoke(
+            row: Int,
+            col: Int,
+        ) = Coordinate(Row(row), Col(col))
+    }
 }

src/main/kotlin/domain/GameResult.kt

@@ -0,0 +1,6 @@
+package domain
+
+enum class GameResult {
+    SUCCESS,
+    FAILURE,
+}

src/main/kotlin/domain/MineBoard.kt

@@ -13,10 +13,41 @@ class MineBoard(
                 continue
             }
 
-            if (cells.getCoordinateIs(nextCoordinate).isMineCell()) {
+            if (cells.get(nextCoordinate).isMineCell()) {
                 numberOfMines++
             }
         }
         return numberOfMines
     }
+
+    fun getAdjacentCoordinates(cell: Cell): List<Coordinate> {
+        val adjacentCoordinates = mutableListOf<Coordinate>()
+
+        for (direction in Direction.entries) {
+            val nextCoordinate = cell.coordinate + direction.offset
+            if (!mineGameMetric.isOutOfMineBoard(nextCoordinate)) {
+                adjacentCoordinates.add(nextCoordinate)
+            }
+        }
+
+        return adjacentCoordinates
+    }
+
+    fun isMineCell(coordinate: Coordinate): Boolean {
+        return cells.get(coordinate).isMineCell()
+    }
+
+    fun isAnyMineCellOpened(): Boolean {
+        return cells.countOpenedMineCells() > 0
+    }
+
+    fun isAllEmptyCellsOpened(): Boolean {
+        return cells.isAllEmptyCellsOpened()
+    }
+
+    fun openCell(coordinate: Coordinate) {
+        cells.get(coordinate).open()
+    }
+
+    fun getCell(current: Coordinate): Cell = cells.get(current)
 }

src/main/kotlin/domain/MineSweeperGame.kt

@@ -0,0 +1,44 @@
+package domain
+
+class MineSweeperGame(private val mineBoard: MineBoard) {
+    fun isContinueGame(): Boolean {
+        when {
+            mineBoard.isAnyMineCellOpened() -> return false
+            mineBoard.isAllEmptyCellsOpened() -> return false
+        }
+        return true
+    }
+
+    fun openAdjacentCell(coordinate: Coordinate) {
+        val queue = ArrayDeque<Coordinate>()
+        queue.add(coordinate)
+
+        while (queue.isNotEmpty()) {
+            processCell(queue)
+        }
+    }
+
+    private fun processCell(queue: ArrayDeque<Coordinate>) {
+        val current = queue.removeFirst()
+        val cell = mineBoard.getCell(current)
+
+        if (cell.isAlreadyOpened()) return
+
+        mineBoard.openCell(current)
+
+        if (shouldAddAdjacentCells(cell)) {
+            val adjacentCoordinates = mineBoard.getAdjacentCoordinates(cell)
+            queue.addAll(adjacentCoordinates)
+        }
+    }
+
+    private fun shouldAddAdjacentCells(cell: Cell): Boolean {
+        return cell is Cell.EmptyCell && mineBoard.countAdjacentMines(cell) == 0
+    }
+
+    fun getGameResult(): GameResult =
+        when {
+            mineBoard.isAllEmptyCellsOpened() -> GameResult.SUCCESS
+            else -> GameResult.FAILURE
+        }
+}

src/main/kotlin/view/InputView.kt

@@ -1,5 +1,9 @@
 package view
 
+import domain.Col
+import domain.Coordinate
+import domain.Row
+
 object InputView {
     fun inputRowSize(): Int {
         println("높이를 입력하세요.")
@@ -24,5 +28,20 @@ object InputView {
         return intValue
     }
 
+    fun askMineCoordinate(): Coordinate {
+        println("지뢰찾기 게임 시작")
+        print("open: ")
+        return parseToCoordinateOrThrow(readln())
+    }
+
+    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)) }
+    }
+
     private const val INVALID_INPUT = "숫자만 입력할 수 있습니다."
+    private const val INVALID_COORDINATE = "두가지 숫자를 콤마(,)로 구분해서 입력해주세요 "
 }

src/main/kotlin/view/OutputView.kt

@@ -1,24 +1,49 @@
 package view
 
 import domain.Cell
+import domain.CellStatus
+import domain.GameResult
 import domain.MineBoard
+import domain.Row
 
 object OutputView {
     fun showMineSweeperBoard(board: MineBoard) {
         val cells = board.cells
-        val cellsByRow = cells.cells.groupBy { it.coordinate.row.value }
 
-        cellsByRow.toSortedMap().forEach { (_, rowCells) ->
-            val sortedRow = rowCells.sortedBy { it.coordinate.col.value } // 열 기준 정렬
+        val cellsByRow = cells.cells.groupBy { it.coordinate.row }
+        cellsByRow.toSortedMap(Row::compareTo).forEach { (_, rowCells) ->
+            val sortedRow = rowCells.sortedBy { it.coordinate.col.value }
             sortedRow.forEach { cell ->
-                when (cell) {
-                    is Cell.MineCell -> print(MINE_CELL)
-                    is Cell.EmptyCell -> print("${board.countAdjacentMines(cell)} ")
-                }
+                printCell(cell, board)
             }
             println()
         }
     }
 
+    private fun printCell(
+        cell: Cell,
+        board: MineBoard,
+    ) {
+        if (cell.status == CellStatus.CLOSED) {
+            print(CLOSED_CELL)
+            return
+        }
+
+        when (cell) {
+            is Cell.MineCell -> print(MINE_CELL)
+            is Cell.EmptyCell -> print("${board.countAdjacentMines(cell)} ")
+        }
+    }
+
+    fun showGameResult(result: GameResult) {
+        when (result) {
+            GameResult.SUCCESS -> print(SUCCESS_MESSAGE)
+            GameResult.FAILURE -> print(FAIL_MESSAGE)
+        }
+    }
+
     private const val MINE_CELL = "* "
+    private const val CLOSED_CELL = "C "
+    private const val SUCCESS_MESSAGE = "Success Game"
+    private const val FAIL_MESSAGE = "Lose Game."
 }