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

README.md

@@ -57,3 +57,70 @@
 
 (4,0)   (4,1)   (4,2)   (4,3)   (4,4)
 ```
+
+## step3
+- 인접한 숫자있는 칸까지 열림 :: 해당 기능에 대한 실행 로그
+```text
+높이를 입력하세요.
+9
+너비를 입력하세요.
+9
+지뢰는 몇 개인가요?
+9
+지뢰찾기 게임 시작
+open : 1,1
+0 0 2 C C C C C C
+0 0 2 C C C C C C
+0 0 1 C C C C C C
+0 0 1 C C C C C C
+0 0 1 C C C C C C
+0 0 2 C C C C C C
+0 0 1 C C C C C C
+1 1 2 C C C C C C
+C C C C C C C C C
+open : 5,5
+0 0 2 C 2 0 0 0 0
+0 0 2 C 2 0 0 0 0
+0 0 1 C 1 1 1 1 0
+0 0 1 C C C C 1 0
+0 0 1 C 1 1 1 1 0
+0 0 2 C 2 0 0 0 0
+0 0 1 C 1 0 0 1 1
+1 1 2 C 1 1 1 3 C
+C C C C C C C C C
+open : 6,6
+0 0 2 C 2 0 0 0 0
+0 0 2 C 2 0 0 0 0
+0 0 1 C 1 1 1 1 0
+0 0 1 C C C C 1 0
+0 0 1 C 1 1 1 1 0
+0 0 2 C 2 0 0 0 0
+0 0 1 C 1 0 0 1 1
+1 1 2 C 1 1 1 3 C
+C C C C C C C C C
+open : 7,7
+0 0 2 C 2 0 0 0 0
+0 0 2 C 2 0 0 0 0
+0 0 1 C 1 1 1 1 0
+0 0 1 C C C C 1 0
+0 0 1 C 1 1 1 1 0
+0 0 2 C 2 0 0 0 0
+0 0 1 C 1 0 0 1 1
+1 1 2 C 1 1 1 3 C
+C C C C C C C 3 C
+open : 8,8
+0 0 2 * 2 0 0 0 0
+0 0 2 * 2 0 0 0 0
+0 0 1 C 1 1 1 1 0
+0 0 1 C C C * 1 0
+0 0 1 * 1 1 1 1 0
+0 0 2 C 2 0 0 0 0
+0 0 1 * 1 0 0 1 1
+1 1 2 C 1 1 1 3 *
+C * C C C C * 3 *
+Lose Game.
+
+```
+- 해당 동작에 대한 묵시적인 요구사항은 지뢰찾기 게임에서 기반해 구현하였습니다
+  - 지뢰를 밟아 죽으면 -> 모든 지뢰의 위치가 표시되어야 한다
+  - 칸이 열리면 -> 모든 칸이 열림. 숫자가 0인 지역은 주변지역까지 밝히고 숫자나 지뢰가 있는곳을 경계로만 탐색한다

build.gradle.kts

@@ -13,7 +13,7 @@ repositories {
 dependencies {
     testImplementation("org.junit.jupiter", "junit-jupiter", "5.8.2")
     testImplementation("org.assertj", "assertj-core", "3.22.0")
-    testImplementation("io.kotest", "kotest-runner-junit5", "5.6.2")
+    testImplementation("io.kotest", "kotest-runner-junit5", "5.7.2")
 }
 
 tasks {

src/main/kotlin/minesweeper/Controller.kt

@@ -1,15 +1,18 @@
 package minesweeper
 
+import minesweeper.app.MineSweeperGame
 import minesweeper.model.board.Board
+import minesweeper.model.board.toBoardLimit
 import minesweeper.view.InputView
 import minesweeper.view.OutputView
-import minesweeper.view.reder.impl.AdjacentMineCountRenderingStrategy
+import minesweeper.view.render.impl.ExploringDefaultClosedAreaRenderingStrategy
 
 fun main() {
     val mapHeight: Int = InputView.mapHeight()
     val mapWidth: Int = InputView.mapWidth()
     val minesCount: Int = InputView.countOfMines()
-    val board = Board(minesCount, mapHeight, mapWidth)
-    val outputView = OutputView(AdjacentMineCountRenderingStrategy(board))
-    outputView.printMineMap(board)
+    val board = Board(minesCount, (mapHeight to mapWidth).toBoardLimit())
+    val outputView = OutputView(ExploringDefaultClosedAreaRenderingStrategy)
+    val game = MineSweeperGame(InputView, outputView)
+    game.start(board)
 }

src/main/kotlin/minesweeper/app/GameStatus.kt

@@ -0,0 +1,7 @@
+package minesweeper.app
+
+enum class GameStatus {
+    RUNNING,
+    LOSE,
+    WIN,
+}

src/main/kotlin/minesweeper/app/MineSweeperGame.kt

@@ -0,0 +1,32 @@
+package minesweeper.app
+
+import minesweeper.model.board.Board
+import minesweeper.view.CoordinateParser
+import minesweeper.view.InputView
+import minesweeper.view.OutputView
+
+class MineSweeperGame(
+    private val inputView: InputView,
+    private val outputView: OutputView,
+) {
+    fun start(board: Board) {
+        initialize()
+        run(board)
+        finalize()
+    }
+
+    private fun initialize() {
+        outputView.gameStart()
+    }
+
+    private fun run(board: Board) {
+        do {
+            val status = board.tryOpen(inputView.openCoordinate(CoordinateParser))
+            outputView.printMineMap(board)
+        } while (GameStatus.RUNNING == status)
+    }
+
+    private fun finalize() {
+        outputView.printGameResult()
+    }
+}

src/main/kotlin/minesweeper/model/board/Board.kt

@@ -1,51 +1,63 @@
 package minesweeper.model.board
 
-import minesweeper.model.board.impl.EvenlyStrategy
+import minesweeper.app.GameStatus
+import minesweeper.model.board.minedeploy.impl.EvenlyStrategy
+import minesweeper.model.board.traversal.SearchEngine
+import minesweeper.model.board.traversal.impl.SearchBfs
 import minesweeper.model.point.Attribute
 import minesweeper.model.point.Coordinate
-import minesweeper.model.point.Delta
-import minesweeper.model.point.Delta.Companion.deltas
-import minesweeper.model.point.Points
+import minesweeper.model.vison.impl.VisionTotalCoveringStrategy
 
 class Board(
-    val points: Points,
-    val verticalSize: Int,
-    val horizontalSize: Int,
+    val mines: Mines,
+    private val vision: Vision = Vision(emptySet()),
+    val limit: BoardLimit,
 ) {
+    private val isWin: Boolean
+        get() = mines.count == vision.coveredCount
+
+    val minesCount: Int
+        get() = mines.count
 
     constructor(
         mineCount: Int,
-        verticalSize: Int,
-        horizontalSize: Int,
+        limit: BoardLimit,
     ) : this(
-        points = EvenlyStrategy(mineCount).deployPoints(verticalSize, horizontalSize),
-        verticalSize = verticalSize,
-        horizontalSize = horizontalSize
+        mines = Mines(EvenlyStrategy(mineCount).deployPoints(limit), limit),
+        vision = Vision(VisionTotalCoveringStrategy.coordinates(limit)),
+        limit = limit,
     )
 
-    fun minesCount(): Int {
-        return points.countOfMine()
+    fun isCovered(coordinate: Coordinate): Boolean {
+        return vision.isCovered(coordinate)
+    }
+
+    fun tryOpen(coordinate: Coordinate): GameStatus {
+        if (isMineDeployed(coordinate)) {
+            discoveredAllMines()
+            return GameStatus.LOSE
+        }
+        if (isWin) {
+            return GameStatus.WIN
+        }
+        discoveredAdjacentGround(coordinate)
+        return GameStatus.RUNNING
     }
 
-    fun adjacentMineCount(coordinate: Coordinate): Int {
-        return this.adjacentPointTraversal(coordinate)
-            .asSequence()
-            .map { points.attribute(it) }
-            .count { it == Attribute.MINE }
+    private fun discoveredAdjacentGround(coordinate: Coordinate) {
+        val coordinates: Set<Coordinate> = adjacentGroundCoordinates(coordinate)
+        vision.exposeAll(coordinates)
     }
 
-    private fun adjacentPointTraversal(coordinate: Coordinate): List<Coordinate> {
-        return deltas.asSequence()
-            .filter { delta -> inRange(coordinate, delta) }
-            .map { coordinate.moveTo(it) }
-            .toList()
+    private fun adjacentGroundCoordinates(coordinate: Coordinate): Set<Coordinate> {
+        val searchEngine: SearchEngine = SearchBfs(this.limit, this.mines)
+        return searchEngine.traversal(coordinate)
     }
 
-    private fun inRange(coordinate: Coordinate, delta: Delta): Boolean {
-        return coordinate.movePossible(
-            delta = delta,
-            verticalLimit = verticalSize,
-            horizontalLimit = horizontalSize
-        )
+    private fun discoveredAllMines() {
+        vision.exposeAll(mines.coordinates)
     }
+
+    private fun isMineDeployed(coordinate: Coordinate): Boolean =
+        mines.attribute(coordinate) == Attribute.MINE
 }

src/main/kotlin/minesweeper/model/board/BoardLimit.kt

@@ -0,0 +1,27 @@
+package minesweeper.model.board
+
+import minesweeper.model.point.Horizontal
+import minesweeper.model.point.Vertical
+
+data class BoardLimit(
+    val verticalLimit: Vertical,
+    val horizontalLimit: Horizontal,
+) {
+    val area: Int
+        get() = this.verticalLimit.value * this.horizontalLimit.value
+
+    fun verticalRange(): IntRange {
+        return this.verticalLimit.range()
+    }
+
+    fun horizontalRange(): IntRange {
+        return this.horizontalLimit.range()
+    }
+}
+
+fun Pair<Int, Int>.toBoardLimit(): BoardLimit {
+    return BoardLimit(
+        Vertical(this.first),
+        Horizontal(this.second)
+    )
+}

src/main/kotlin/minesweeper/model/board/Mines.kt

@@ -0,0 +1,52 @@
+package minesweeper.model.board
+
+import minesweeper.model.point.Attribute
+import minesweeper.model.point.Coordinate
+import minesweeper.model.point.Delta
+
+class Mines(
+    private val deployedCoordinate: Map<Coordinate, Attribute>,
+    private val limit: BoardLimit,
+) {
+
+    val count: Int
+        get() = deployedCoordinate.values.count { it == Attribute.MINE }
+
+    val coordinates: Set<Coordinate>
+        get() = deployedCoordinate.keys
+
+    private fun isDeployedCoordinate(coordinate: Coordinate): Boolean {
+        return deployedCoordinate.containsKey(coordinate)
+    }
+
+    fun attribute(coordinate: Coordinate): Attribute {
+        return when (this.isDeployedCoordinate(coordinate)) {
+            true -> Attribute.MINE
+            false -> Attribute.GROUND
+        }
+    }
+
+    fun isGround(coordinate: Coordinate): Boolean =
+        this.attribute(coordinate) == Attribute.GROUND
+
+    fun isAdjacentMineCountZero(coordinate: Coordinate): Boolean =
+        this.adjacentMineCount(coordinate) == 0
+
+    fun adjacentMineCount(coordinate: Coordinate): Int {
+        return Delta.deltas.asSequence()
+            .filter { delta -> inRange(coordinate, delta) }
+            .map { this.attribute(coordinate.moveTo(it)) }
+            .count { it.isMine() }
+    }
+
+    private fun inRange(coordinate: Coordinate, delta: Delta): Boolean {
+        return coordinate.movePossible(
+            delta = delta,
+            limit = limit
+        )
+    }
+}
+
+fun Map<Coordinate, Attribute>.toMines(limit: BoardLimit): Mines {
+    return Mines(this, limit)
+}

src/main/kotlin/minesweeper/model/board/Vision.kt

@@ -0,0 +1,27 @@
+package minesweeper.model.board
+
+import minesweeper.model.point.Coordinate
+
+class Vision(coordinates: Set<Coordinate>) {
+
+    private val coveredCoordinates: MutableSet<Coordinate>
+
+    val coveredCount: Int
+        get() = coveredCoordinates.size
+
+    init {
+        this.coveredCoordinates = coordinates.toMutableSet()
+    }
+
+    fun exposeAll(coordinates: Set<Coordinate>) {
+        this.coveredCoordinates.removeAll(coordinates)
+    }
+
+    fun isCovered(coordinate: Coordinate): Boolean {
+        return coveredCoordinates.contains(coordinate)
+    }
+}
+
+fun Set<Coordinate>.toVision(): Vision {
+    return Vision(this)
+}

src/main/kotlin/minesweeper/model/board/minedeploy/MineDeployStrategy.kt

@@ -0,0 +1,9 @@
+package minesweeper.model.board.minedeploy
+
+import minesweeper.model.board.BoardLimit
+import minesweeper.model.point.Attribute
+import minesweeper.model.point.Coordinate
+
+interface MineDeployStrategy {
+    fun deployPoints(boardLimit: BoardLimit): Map<Coordinate, Attribute>
+}