Step3: 지뢰 찾기(게임 실행)

README.md

@@ -8,4 +8,10 @@
 - [X] 8방면 포인트는 row 및 column 사이에 있는 포인트 묶음을 반환한다.
 - [X] 지뢰에 다 둘러쌓여 있으면 Blank의 nearCount는 8이다.
 - [X] 지뢰에 안 둘러쌓여 있다면 MineMap에 정보가 없다.
-- [X] 근처 지뢰가 있냐에 따라 카운트가 달라진다.
+- [X] 근처 지뢰가 있냐에 따라 카운트가 달라진다.
+
+- [X] 클릭 시 이미 클릭한 구역이라면, 이미 클릭한 것이라 알려준다.
+- [X] 클릭 시 주변 지뢰 수가 0이라면, 주변의 0인 구역 및 0이 아닌 구역 모두를 보여준다
+- [X] 클릭 시 주변 지뢰 수가 1 이상이라면, 클릭한 부분만 보여준다
+- [X] 클릭 시 지뢰라면, 그 즉시 패배로 게임이 끝난다.
+- [X] 지뢰 외 모든 구역을 다 찾았다면, 승리로 끝난다.

src/main/kotlin/minesweeper/Direction.kt

@@ -0,0 +1,12 @@
+package minesweeper
+
+enum class Direction(val row: Int, val col: Int) {
+    NORTH(-1, 0),
+    NORTHEAST(-1, 1),
+    EAST(0, 1),
+    SOUTHEAST(1, 1),
+    SOUTH(1, 0),
+    SOUTHWEST(1, -1),
+    WEST(0, -1),
+    NORTHWEST(-1, -1)
+}

src/main/kotlin/minesweeper/InputView.kt

@@ -9,6 +9,12 @@ object InputView {
         println("지뢰는 몇 개인가요?")
         val mineNum = MineCount(readln().toInt())
 
-        return MineMap(MineMapInfo(row, col, mineNum))
+        return MineMap.create(MineMapInfo(row, col, mineNum))
+    }
+
+    fun getClickedPoint(): Point {
+        print("open: ")
+        val pointString = readln().split(",").map { it.trim().toInt() }
+        return Point(pointString[0], pointString[1])
     }
 }

src/main/kotlin/minesweeper/Main.kt

@@ -1,6 +1,32 @@
 package minesweeper
 
 fun main() {
-    val mineMap = InputView.getMineMap()
-    ResultView.showMap(mineMap)
+    val mineSweeper = MineSweeper(InputView.getMineMap())
+    ResultView.start()
+
+    do {
+        val clicked = InputView.getClickedPoint()
+        val result = mineSweeper.click(clicked)
+        when (result) {
+            MineSweeper.ClickResult.CONTINUE -> {
+                ResultView.showMap(mineSweeper)
+            }
+
+            MineSweeper.ClickResult.ALREADY_CLICKED -> {
+                ResultView.showAlreadyClickedMessage()
+            }
+
+            MineSweeper.ClickResult.GAME_OVER -> {
+                ResultView.showGameOver()
+                break
+            }
+
+            MineSweeper.ClickResult.ERROR -> {
+                ResultView.showError()
+                break
+            }
+        }
+    } while (!mineSweeper.isDone)
+
+    if (mineSweeper.isDone) ResultView.showFinished()
 }

src/main/kotlin/minesweeper/MapSize.kt

@@ -0,0 +1,3 @@
+package minesweeper
+
+data class MapSize(val row: LineCount, val column: LineCount)

src/main/kotlin/minesweeper/MapTile.kt

@@ -6,5 +6,7 @@ sealed class MapTile {
         operator fun plus(number: Int): Blank {
             return Blank(this.nearCount + number)
         }
+
+        val isNoMineNear = nearCount == 0
     }
 }

src/main/kotlin/minesweeper/MineCount.kt

@@ -3,7 +3,7 @@ package minesweeper
 @JvmInline
 value class MineCount(val count: Int) {
     init {
-        require(count > 0) {
+        require(count >= 0) {
             "Mine Number must be positive"
         }
     }

src/main/kotlin/minesweeper/MineMap.kt

@@ -1,26 +1,49 @@
 package minesweeper
 
 class MineMap(
-    val mineMapInfo: MineMapInfo,
-    createStrategy: MinePointCreateStrategy = RandomPointCreateStrategy()
+    val mineMap: Map<Point, MapTile>,
+    val mapInfo: MineMapInfo
 ) {
-    private val mineList: MineList =
-        MineList.createMineList(mineMapInfo, createStrategy)
-    val mineMap: Map<Point, MapTile> = mutableMapOf<Point, MapTile>().apply {
-        for (mine in mineList.mineList) {
-            this[mine] = MapTile.Mine
+    val totalSize = mapInfo.totalNumber
+
+    companion object {
+        fun create(
+            mineMapInfo: MineMapInfo,
+            createStrategy: MinePointCreateStrategy = RandomPointCreateStrategy()
+        ): MineMap {
+            val mineList: MineList =
+                MineList.createMineList(mineMapInfo, createStrategy)
+
+            return MineMap(
+                emptyMap(mineMapInfo.mapSize).apply {
+                    for (mine in mineList.mineList) {
+                        this[mine] = MapTile.Mine
+                    }
+
+                    for (mine in mineList.mineList) {
+                        createNear(this, mine, mineMapInfo.mapSize)
+                    }
+                },
+                mineMapInfo
+            )
         }
 
-        for (mine in mineList.mineList) {
-            createNear(this, mine)
+        private fun emptyMap(mapSize: MapSize): MutableMap<Point, MapTile> {
+            return mutableMapOf<Point, MapTile>().apply {
+                for (i in 1..mapSize.row.count) {
+                    for (j in 1..mapSize.column.count) {
+                        put(Point(i, j), MapTile.Blank(0))
+                    }
+                }
+            }
         }
-    }
 
-    private fun createNear(map: MutableMap<Point, MapTile>, mine: Point) {
-        val adjacentPoints = AdjacentPoints.create(mine, mineMapInfo.rowCnt, mineMapInfo.colCnt)
-        for (adj in adjacentPoints.points) {
-            val nearInfo = map.getOrDefault(adj, MapTile.Blank(0))
-            if (nearInfo is MapTile.Blank) map[adj] = nearInfo + 1
+        private fun createNear(map: MutableMap<Point, MapTile>, mine: Point, mapSize: MapSize) {
+            val adjacentPoints = mine.getAdjacentPoints(mapSize)
+            for (adj in adjacentPoints) {
+                val nearInfo = map[adj]
+                if (nearInfo is MapTile.Blank) map[adj] = nearInfo + 1
+            }
         }
     }
 }

src/main/kotlin/minesweeper/MineMapInfo.kt

@@ -1,14 +1,16 @@
 package minesweeper
 
-data class MineMapInfo(private val rowNum: LineCount, private val colNum: LineCount, private val mineNum: MineCount) {
-    val rowCnt = rowNum.count
-    val colCnt = colNum.count
-    val mineCnt = mineNum.count
+data class MineMapInfo(val mapSize: MapSize, private val mineCount: MineCount) {
+    constructor(row: LineCount, col: LineCount, mineNum: MineCount) : this(MapSize(row, col), mineNum)
 
-    val total = rowCnt * colCnt
+    val rowNumber = mapSize.row.count
+    val columnNumber = mapSize.column.count
+    val mineNumber = mineCount.count
+
+    val totalNumber = rowNumber * columnNumber
 
     init {
-        require(mineCnt <= total) {
+        require(mineNumber <= totalNumber) {
             "Mine Count should not be bigger than total map tile"
         }
     }

src/main/kotlin/minesweeper/MinePointCreateStrategy.kt

@@ -2,10 +2,4 @@ package minesweeper
 
 interface MinePointCreateStrategy {
     fun createMinePoints(mineMapInfo: MineMapInfo): List<Point>
-
-    fun Int.toPoint(rowNum: Int): Point {
-        val rowIdx = this / rowNum
-        val colIdx = this % rowNum
-        return Point(rowIdx, colIdx)
-    }
 }

src/main/kotlin/minesweeper/MineSweeper.kt

@@ -0,0 +1,57 @@
+package minesweeper
+
+class MineSweeper(
+    val mineMap: MineMap,
+    clickedSet: Set<Point> = setOf(),
+) {
+    var clickedSet: Set<Point> = clickedSet
+        private set
+
+    val isDone get() = clickedSet.size == mineMap.totalSize - mineMap.mapInfo.mineNumber
+
+    fun click(point: Point): ClickResult {
+        if (clickedSet.contains(point)) return ClickResult.ALREADY_CLICKED
+
+        return when (val clickedTile = mineMap.mineMap[point]) {
+            is MapTile.Mine -> ClickResult.GAME_OVER
+            is MapTile.Blank -> {
+                setBlankTile(point, clickedTile)
+                ClickResult.CONTINUE
+            }
+
+            else -> ClickResult.ERROR
+        }
+    }
+
+    private fun setBlankTile(point: Point, clickedTile: MapTile.Blank) {
+        setClickedPoint(point)
+        if (clickedTile.isNoMineNear) {
+            setAdjacentTilesClicked(point)
+        }
+    }
+
+    private fun setAdjacentTilesClicked(point: Point) {
+        val adjacent = point.getAdjacentPoints(mineMap.mapInfo.mapSize)
+        for (adj in adjacent) {
+            if (clickedSet.contains(adj)) continue
+
+            adjacentTileDfs(adj)
+        }
+    }
+
+    private fun adjacentTileDfs(adj: Point) {
+        val info = mineMap.mineMap[adj]
+        if (info is MapTile.Blank) {
+            setClickedPoint(adj)
+            if (info.isNoMineNear) setAdjacentTilesClicked(adj)
+        }
+    }
+
+    private fun setClickedPoint(point: Point) {
+        clickedSet = clickedSet.plus(point)
+    }
+
+    enum class ClickResult {
+        GAME_OVER, ALREADY_CLICKED, CONTINUE, ERROR
+    }
+}

src/main/kotlin/minesweeper/Point.kt

@@ -1,3 +1,18 @@
 package minesweeper
 
-data class Point(val row: Int, val col: Int)
+data class Point(val row: Int, val col: Int) {
+    fun getAdjacentPoints(mapSize: MapSize): List<Point> {
+        val mapRow = mapSize.row.count
+        val mapCol = mapSize.column.count
+        return buildList {
+            for (dir in Direction.values()) {
+                val nearPoint = Point(row + dir.row, col + dir.col)
+                if (nearPoint.isOutOfBound(mapRow, mapCol)) continue
+                add(nearPoint)
+            }
+        }
+    }
+
+    private fun Point.isOutOfBound(mapRow: Int, mapCol: Int): Boolean =
+        this.row < 1 || this.col < 1 || this.row > mapRow || this.col > mapCol
+}

src/main/kotlin/minesweeper/RandomPointCreateStrategy.kt

@@ -2,10 +2,16 @@ package minesweeper
 
 class RandomPointCreateStrategy : MinePointCreateStrategy {
     override fun createMinePoints(mineMapInfo: MineMapInfo): List<Point> {
-        val tileNum = mineMapInfo.rowCnt * mineMapInfo.colCnt - 1
+        val tileNum = mineMapInfo.rowNumber * mineMapInfo.columnNumber - 1
         return (0..tileNum).toList()
             .shuffled()
-            .take(mineMapInfo.mineCnt)
-            .map { it.toPoint(mineMapInfo.rowCnt) }
+            .take(mineMapInfo.mineNumber)
+            .map { it.toPoint(mineMapInfo.rowNumber) }
+    }
+
+    private fun Int.toPoint(rowNum: Int): Point {
+        val rowIdx = this / rowNum
+        val colIdx = this % rowNum
+        return Point(rowIdx + 1, colIdx + 1)
     }
 }

src/main/kotlin/minesweeper/ResultView.kt

@@ -1,19 +1,27 @@
 package minesweeper
 
 object ResultView {
-    fun showMap(mineMap: MineMap) {
+    fun start() {
         println("지뢰찾기 게임 시작")
-        for (row in 0 until mineMap.mineMapInfo.rowCnt) {
-            printRow(mineMap, row)
+    }
+
+    fun showMap(mineSweeper: MineSweeper) {
+        for (row in 1..mineSweeper.mineMap.mapInfo.rowNumber) {
+            printRow(mineSweeper, row)
         }
     }
 
     private fun printRow(
-        mineMap: MineMap,
+        mineSweeper: MineSweeper,
         row: Int
     ) {
-        for (col in 0 until mineMap.mineMapInfo.colCnt) {
-            when (val info = mineMap.mineMap[Point(row, col)]) {
+        for (col in 1..mineSweeper.mineMap.mapInfo.columnNumber) {
+            val point = Point(row, col)
+            if (!mineSweeper.clickedSet.contains(point)) {
+                print("C ")
+                continue
+            }
+            when (val info = mineSweeper.mineMap.mineMap[point]) {
                 is MapTile.Mine -> print("* ")
                 is MapTile.Blank -> {
                     print("${info.nearCount} ")
@@ -24,4 +32,20 @@ object ResultView {
         }
         println()
     }
+
+    fun showAlreadyClickedMessage() {
+        println("This point is already clicked. Choose other point.")
+    }
+
+    fun showGameOver() {
+        println("Lose Game.")
+    }
+
+    fun showError() {
+        println("Error.")
+    }
+
+    fun showFinished() {
+        println("Congratulation! You win the game!")
+    }
 }