Step2

src/main/kotlin/minesweeper/README.md

@@ -31,4 +31,12 @@
   - [x] `View`를 `Interface`로 변경
 - [x] `View` 에서 처리해야할 로직들 이동
    - [x] `Blcok` 클래스의 `mark` 삭제 -> `View`로 이동
-   - [x] 모델들의 `toString()` -> `View`로 이동
+   - [x] 모델들의 `toString()` -> `View`로 이동
+
+
+## 2단계
+- [x] 주변의 지뢰 숫자를 보여주는 기능
+  - [x] `Point` - 근처의 포인트 객체들 받아오기
+  - [x] `SafeBlock` - 주변의 지뢰 수를 가지는 프로퍼티 생성
+  - [x] `MineSweeperBoard` - 지뢰를 심은 뒤에 지뢰의 수를 반영하는 메소드 생성
+  - [x] `ResultView` - SafeBlock 표기 방식 변경

src/main/kotlin/minesweeper/controller/GameController.kt

@@ -1,8 +1,8 @@
 package minesweeper.controller
 
-import minesweeper.domain.Block
 import minesweeper.domain.MineSweeperBoard
-import minesweeper.domain.Point
+import minesweeper.domain.exception.MineSweeperException
+import minesweeper.domain.plant_strategy.RemainderPlantStrategy
 import minesweeper.view.InputView
 import minesweeper.view.InputViewImpl
 import minesweeper.view.ResultView
@@ -12,17 +12,25 @@ class GameController(
     private val inputView: InputView = InputViewImpl(),
     private val resultView: ResultView = ResultViewImpl()
 ) {
-    fun run(): Map<Point, Block> {
-        val gameBoard = setUp()
-        resultView.renderInitialBoard(gameBoard.state)
-        return gameBoard.state
+    fun run(): MineSweeperBoard? {
+        return try {
+            val gameBoard = setUp()
+            resultView.renderInitialBoard(gameBoard.state)
+            gameBoard
+        } catch (e: MineSweeperException) {
+            resultView.printKnownException(e)
+            throw e
+        } catch (e: Exception) {
+            resultView.printUnknownException(e)
+            throw e
+        }
     }
 
     private fun setUp(): MineSweeperBoard {
         val height = inputView.readHeight()
         val width = inputView.readWidth()
         val mineCount = inputView.readMineCount()
 
-        return MineSweeperBoard(height, width, mineCount)
+        return MineSweeperBoard(height, width, mineCount, RemainderPlantStrategy())
     }
 }

src/main/kotlin/minesweeper/domain/MineSweeperBoard.kt

@@ -1,8 +1,19 @@
 package minesweeper.domain
 
-import java.util.Random
+import minesweeper.domain.block.Block
+import minesweeper.domain.block.MineBlock
+import minesweeper.domain.block.SafeBlock
+import minesweeper.domain.exception.ExceptionReason
+import minesweeper.domain.exception.MineSweeperException
+import minesweeper.domain.plant_strategy.PlantStrategy
+import minesweeper.domain.plant_strategy.RemainderPlantStrategy
 
-class MineSweeperBoard(private val width: Int, private val height: Int, mineCount: Int = 0) {
+class MineSweeperBoard(
+    private val width: Int,
+    private val height: Int,
+    mineCount: Int = 0,
+    private val strategy: PlantStrategy = RemainderPlantStrategy()
+) {
 
     private val _state: MutableMap<Point, Block>
 
@@ -20,17 +31,12 @@ class MineSweeperBoard(private val width: Int, private val height: Int, mineCoun
         }
         _state = buildBoard(width, height).toMutableMap()
         plantMines(mineCount)
-        _mineCount = countMine()
     }
 
     private fun buildBoard(maxXAxis: Int, maxYAxis: Int): Map<Point, Block> {
-        val pairs = mutableListOf<Pair<Point, Block>>()
-
-        (0 until maxXAxis).forEach { currentXAixs ->
-            pairs.addAll(buildLine(currentXAixs, maxYAxis))
-        }
-
-        return pairs.toMap()
+        return (0 until maxXAxis).flatMap { currentXAxis ->
+            buildLine(currentXAxis, maxYAxis)
+        }.toMap()
     }
 
     private fun buildLine(currentXAxis: Int, maxYAxis: Int): List<Pair<Point, Block>> {
@@ -44,13 +50,25 @@ class MineSweeperBoard(private val width: Int, private val height: Int, mineCoun
     }
 
     private fun plantMines(plantingMineCount: Int) {
-        while (countMine() < plantingMineCount) {
-            val width = Random().nextInt(width)
-            val height = Random().nextInt(height)
-            _state[Point(width, height)] = MineBlock()
+        val minePoints = strategy.createMines(width, height, plantingMineCount)
+        minePoints.forEach {
+            _state[it] = MineBlock()
+        }
+        _mineCount = countMine()
+        updateSafeBlock()
+    }
+
+    private fun updateSafeBlock() {
+        val safeBlockPoints = _state.filterValues { block: Block -> block is SafeBlock }.keys
+        safeBlockPoints.forEach { currentPoint: Point ->
+            _state[currentPoint] = SafeBlock(sumNearPointMines(currentPoint.getNearPoints(width, height)))
         }
     }
 
+    private fun sumNearPointMines(points: List<Point>): Int {
+        return points.count { _state[it] is MineBlock }
+    }
+
     private fun countMine(): Int {
         return _state.values.count { block: Block -> block is MineBlock }
     }

src/main/kotlin/minesweeper/domain/Point.kt

@@ -1,5 +1,8 @@
 package minesweeper.domain
 
+import minesweeper.domain.exception.ExceptionReason
+import minesweeper.domain.exception.MineSweeperException
+
 data class Point(val x: Int, val y: Int) : Comparable<Point> {
 
     init {
@@ -8,5 +11,38 @@ data class Point(val x: Int, val y: Int) : Comparable<Point> {
         }
     }
 
+    fun getNearPoints(width: Int, height: Int): List<Point> {
+        val nearPoints = nearPoints.toList()
+        return nearPoints.mapNotNull { plusOrNull(it.first, it.second, width, height) }
+    }
+
     override fun compareTo(other: Point) = compareValuesBy(this, other, { it.y }, { it.x })
+
+    private fun plusOrNull(x: Int, y: Int, maxX: Int, maxY: Int): Point? {
+        if (isValidateX(x, maxX) && isValidateY(y, maxY)) {
+            return Point(this.x + x, this.y + y)
+        }
+        return null
+    }
+
+    private fun isValidateX(x: Int, maxX: Int): Boolean {
+        return (this.x + x) in 0 until maxX
+    }
+
+    private fun isValidateY(y: Int, maxY: Int): Boolean {
+        return (this.y + y) in 0 until maxY
+    }
+
+    companion object {
+        private val nearPoints = listOf(
+            -1 to -1,
+            -1 to 0,
+            -1 to 1,
+            0 to -1,
+            0 to 1,
+            1 to -1,
+            1 to 0,
+            1 to 1
+        )
+    }
 }

src/main/kotlin/minesweeper/domain/block/Block.kt

@@ -0,0 +1,5 @@
+package minesweeper.domain.block
+
+sealed class Block {
+    abstract fun open()
+}

src/main/kotlin/minesweeper/domain/block/MineBlock.kt

@@ -0,0 +1,7 @@
+package minesweeper.domain.block
+
+class MineBlock : Block() {
+    override fun open() {
+        TODO("Not yet implemented")
+    }
+}

src/main/kotlin/minesweeper/domain/block/SafeBlock.kt

@@ -0,0 +1,19 @@
+package minesweeper.domain.block
+
+import minesweeper.domain.exception.ExceptionReason
+import minesweeper.domain.exception.MineSweeperException
+
+class SafeBlock(val nearMineCount: Int = 0) : Block() {
+
+    init {
+        if (nearMineCount !in nearMineRange) throw MineSweeperException(ExceptionReason.ILLEGAL_NEAR_MINE_RANGE)
+    }
+
+    override fun open() {
+        TODO("Not yet implemented")
+    }
+
+    companion object {
+        private val nearMineRange = (0..8)
+    }
+}

src/main/kotlin/minesweeper/domain/exception/ExceptionReason.kt

@@ -0,0 +1,8 @@
+package minesweeper.domain.exception
+
+enum class ExceptionReason {
+    ILLEGAL_POINT,
+    NEGATIVE_POINT_VALUE,
+    MINE_COUNT_OVER_BLOCKS,
+    ILLEGAL_NEAR_MINE_RANGE
+}

src/main/kotlin/minesweeper/domain/MineSweeperException.kt → src/main/kotlin/minesweeper/domain/exception/MineSweeperException.kt

@@ -1,3 +1,3 @@
-package minesweeper.domain
+package minesweeper.domain.exception
 
 class MineSweeperException(val reason: ExceptionReason) : Exception()

src/main/kotlin/minesweeper/domain/plant_strategy/PlantStrategy.kt

@@ -0,0 +1,7 @@
+package minesweeper.domain.plant_strategy
+
+import minesweeper.domain.Point
+
+interface PlantStrategy {
+    fun createMines(width: Int, height: Int, mineCount: Int): Set<Point>
+}

src/main/kotlin/minesweeper/domain/plant_strategy/RandomPlantStrategy.kt

@@ -0,0 +1,16 @@
+package minesweeper.domain.plant_strategy
+
+import minesweeper.domain.Point
+import java.util.*
+
+class RandomPlantStrategy : PlantStrategy {
+    override fun createMines(width: Int, height: Int, mineCount: Int): Set<Point> {
+        val minePoints = mutableSetOf<Point>()
+        while (minePoints.size < mineCount) {
+            val currentWidth = Random().nextInt(width)
+            val currentHeight = Random().nextInt(height)
+            minePoints.add(Point(currentWidth, currentHeight))
+        }
+        return minePoints
+    }
+}

src/main/kotlin/minesweeper/domain/plant_strategy/RemainderPlantStrategy.kt

@@ -0,0 +1,22 @@
+package minesweeper.domain.plant_strategy
+
+import minesweeper.domain.Point
+
+class RemainderPlantStrategy : PlantStrategy {
+
+    override fun createMines(width: Int, height: Int, mineCount: Int): Set<Point> {
+        val minePoints = mutableSetOf<Point>()
+
+        val term = width * height / mineCount
+        val maxNumber = term * mineCount
+        for (i: Int in 0 until maxNumber step term) {
+            val currentWidth = i % width
+            val currentHeight = i / width
+
+            minePoints.add(Point(currentWidth, currentHeight))
+        }
+
+
+        return minePoints
+    }
+}

src/main/kotlin/minesweeper/view/ResultView.kt

@@ -1,8 +1,12 @@
 package minesweeper.view
 
-import minesweeper.domain.Block
+import minesweeper.domain.block.Block
+import minesweeper.domain.exception.MineSweeperException
 import minesweeper.domain.Point
 
 interface ResultView {
     fun renderInitialBoard(state: Map<Point, Block>)
+
+    fun printKnownException(exception: MineSweeperException)
+    fun printUnknownException(exception: Exception)
 }

src/main/kotlin/minesweeper/view/ResultViewImpl.kt

@@ -1,12 +1,11 @@
 package minesweeper.view
 
-import minesweeper.domain.Block
-import minesweeper.domain.MineBlock
+import minesweeper.domain.block.Block
+import minesweeper.domain.exception.ExceptionReason
+import minesweeper.domain.block.MineBlock
+import minesweeper.domain.exception.MineSweeperException
 import minesweeper.domain.Point
-
-private const val DEFAULT_BLOCK_CHARACTER = "C"
-private const val DEFAULT_MINE_CHARACTER = "*"
-private const val BLANK = " "
+import minesweeper.domain.block.SafeBlock
 
 class ResultViewImpl : ResultView {
     override fun renderInitialBoard(state: Map<Point, Block>) {
@@ -15,6 +14,23 @@ class ResultViewImpl : ResultView {
         renderBoard(state)
     }
 
+    override fun printKnownException(exception: MineSweeperException) {
+        println(parseException(exception))
+    }
+
+    private fun parseException(exception: MineSweeperException): String {
+        return when (exception.reason) {
+            ExceptionReason.NEGATIVE_POINT_VALUE -> NEGATIVE_POINT_VALUE_TEXT
+            ExceptionReason.MINE_COUNT_OVER_BLOCKS -> MINE_COUNT_OVER_BLOCKS_TEXT
+            ExceptionReason.ILLEGAL_NEAR_MINE_RANGE -> ILLEGAL_NEAR_MINE_RANGE_TEXT
+            ExceptionReason.ILLEGAL_POINT -> CANT_CREATE_BLOCK
+        }
+    }
+
+    override fun printUnknownException(exception: Exception) {
+        print(exception.message)
+    }
+
     private fun renderBoard(state: Map<Point, Block>) {
         val yList = state.toList().groupBy { it.first.y }
         yList.forEach {
@@ -30,8 +46,17 @@ class ResultViewImpl : ResultView {
     private fun renderBlock(block: Block) {
         when (block) {
             is MineBlock -> print(DEFAULT_MINE_CHARACTER)
-            else -> print(DEFAULT_BLOCK_CHARACTER)
+            is SafeBlock -> print(block.nearMineCount)
         }
-        print(BLANK)
+        print(BLANK_CHARACTER)
+    }
+
+    companion object {
+        private const val DEFAULT_MINE_CHARACTER = "*"
+        private const val BLANK_CHARACTER = " "
+        private const val NEGATIVE_POINT_VALUE_TEXT = "좌표 값은 음수가 될 수 없습니다."
+        private const val MINE_COUNT_OVER_BLOCKS_TEXT = "지뢰의 개수는 총 블록의 개수보다 많을 수 없습니다."
+        private const val ILLEGAL_NEAR_MINE_RANGE_TEXT = "근처의 지뢰 범위는 0 이상 8 이하입니다."
+        private const val CANT_CREATE_BLOCK = "현재 보드에 없는 지점에 지뢰를 설치할 수 없습니다."
     }
 }