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,7 @@
 package minesweeper.controller
 
-import minesweeper.domain.Block
 import minesweeper.domain.MineSweeperBoard
-import minesweeper.domain.Point
+import minesweeper.domain.MineSweeperException
 import minesweeper.view.InputView
 import minesweeper.view.InputViewImpl
 import minesweeper.view.ResultView
@@ -12,10 +11,18 @@ 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)
+            null
+        } catch (e: Exception) {
+            resultView.printUnknownException(e)
+            null
+        }
     }
 
     private fun setUp(): MineSweeperBoard {

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

@@ -4,14 +4,29 @@ sealed class Block {
     abstract fun open()
 }
 
+class EmptyBlock : Block() {
+    override fun open() {
+        TODO("Not yet implemented")
+    }
+}
+
 class MineBlock : Block() {
     override fun open() {
         TODO("Not yet implemented")
     }
 }
 
-class SafeBlock : Block() {
+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/ExceptionReason.kt

@@ -1,6 +1,8 @@
 package minesweeper.domain
 
-enum class ExceptionReason(val message: String) {
-    NEGATIVE_POINT_VALUE("좌표 값은 음수가 될 수 없습니다."),
-    MINE_COUNT_OVER_BLOCKS("지뢰의 개수는 총 블록의 개수보다 많을 수 없습니다.")
+enum class ExceptionReason {
+    ILLEGAL_POINT,
+    NEGATIVE_POINT_VALUE,
+    MINE_COUNT_OVER_BLOCKS,
+    ILLEGAL_NEAR_MINE_RANGE
 }

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

@@ -21,36 +21,55 @@ class MineSweeperBoard(private val width: Int, private val height: Int, mineCoun
         _state = buildBoard(width, height).toMutableMap()
         plantMines(mineCount)
         _mineCount = countMine()
+        buildSafeBlock()
     }
 
     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 { currentXAixs ->
+            buildLine(currentXAixs, maxYAxis)
+        }.toMap()
     }
 
     private fun buildLine(currentXAxis: Int, maxYAxis: Int): List<Pair<Point, Block>> {
         return (0 until maxYAxis).map { y ->
-            buildBlock(currentXAxis, y)
+            buildEmptyBlock(currentXAxis, y)
         }
     }
 
-    private fun buildBlock(currentXAxis: Int, currentYAxis: Int): Pair<Point, Block> {
-        return Point(currentXAxis, currentYAxis) to SafeBlock()
+    private fun buildEmptyBlock(currentXAxis: Int, currentYAxis: Int): Pair<Point, Block> {
+        return Point(currentXAxis, currentYAxis) to EmptyBlock()
     }
 
     private fun plantMines(plantingMineCount: Int) {
         while (countMine() < plantingMineCount) {
             val width = Random().nextInt(width)
             val height = Random().nextInt(height)
+            validatePoint(Point(width, height))
             _state[Point(width, height)] = MineBlock()
         }
     }
 
+    private fun validatePoint(point: Point) {
+        if (!_state.containsKey(point)) {
+            throw MineSweeperException(ExceptionReason.ILLEGAL_POINT)
+        }
+    }
+
+    private fun buildSafeBlock() {
+        val emptyBlockPoints = findEmptyBlockPoint()
+        emptyBlockPoints.forEach { currentPoint: Point ->
+            _state[currentPoint] = SafeBlock(countNearMine(currentPoint.getNearPoints()))
+        }
+    }
+
+    private fun findEmptyBlockPoint(): Set<Point> {
+        return _state.filterValues { block: Block -> block is EmptyBlock }.keys
+    }
+
+    private fun countNearMine(points: List<Point>): Int {
+        return points.filter { _state[it] is MineBlock }.size
+    }
+
     private fun countMine(): Int {
         return _state.values.count { block: Block -> block is MineBlock }
     }

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

@@ -8,5 +8,30 @@ data class Point(val x: Int, val y: Int) : Comparable<Point> {
         }
     }
 
+    fun getNearPoints(): List<Point> {
+        return nearPoints.mapNotNull { plusOrNull(it.first, it.second) }
+    }
+
     override fun compareTo(other: Point) = compareValuesBy(this, other, { it.y }, { it.x })
+
+    private fun plusOrNull(x: Int, y: Int): Point? {
+        return try {
+            Point(this.x + x, this.y + y)
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    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/view/ResultView.kt

@@ -1,8 +1,12 @@
 package minesweeper.view
 
 import minesweeper.domain.Block
+import minesweeper.domain.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.ExceptionReason
 import minesweeper.domain.MineBlock
+import minesweeper.domain.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.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,19 @@ class ResultViewImpl : ResultView {
     private fun renderBlock(block: Block) {
         when (block) {
             is MineBlock -> print(DEFAULT_MINE_CHARACTER)
+            is SafeBlock -> print(block.nearMineCount)
             else -> print(DEFAULT_BLOCK_CHARACTER)
         }
-        print(BLANK)
+        print(BLANK_CHARACTER)
+    }
+
+    companion object {
+        private const val DEFAULT_BLOCK_CHARACTER = "C"
+        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 = "현재 보드에 없는 지점에 지뢰를 설치할 수 없습니다."
     }
 }

src/test/kotlin/minesweeper/controller/GameControllerTest.kt

@@ -0,0 +1,41 @@
+package minesweeper.controller
+
+import minesweeper.domain.MineBlock
+import minesweeper.domain.MineSweeperBoard
+import minesweeper.view.FakeInputView
+import minesweeper.view.ResultViewImpl
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class GameControllerTest {
+
+    @Test
+    fun `게임 실행이 완료되면 마지막 상태의 유저 요구사항에 맞는 Board를 반환한다`() {
+
+        val userInputHeight = 2
+        val userInputWidth = 2
+        val userInputMineCount = 1
+
+        val controller =
+            GameController(FakeInputView(userInputHeight, userInputWidth, userInputMineCount), ResultViewImpl())
+
+        val board = controller.run()
+        assertThat(board).isExactlyInstanceOf(MineSweeperBoard::class.java)
+        assertThat(board!!.state.size).isEqualTo(userInputWidth * userInputHeight)
+        assertThat(board.state.values.count { it is MineBlock }).isEqualTo(userInputMineCount)
+    }
+
+    @Test
+    fun `게임 실행 도중 예외가 발생하면 null을 반환한다`() {
+
+        val userInputHeight = 2
+        val userInputWidth = 2
+        val userInputMineCount = 5
+
+        val controller =
+            GameController(FakeInputView(userInputHeight, userInputWidth, userInputMineCount), ResultViewImpl())
+
+        val board = controller.run()
+        assertThat(board).isEqualTo(null)
+    }
+}

src/test/kotlin/minesweeper/domain/PointTest.kt

@@ -39,4 +39,25 @@ class PointTest {
 
         assertThat(sortedPoints).isEqualTo(listOf(Point(0, 0), Point(1, 0), Point(2, 0)))
     }
+
+    @Test
+    fun `꼭짓점 블록은 3개의 주변 블록을 가진다`() {
+        val point = Point(0, 0)
+
+        assertThat(point.getNearPoints().size).isEqualTo(3)
+    }
+
+    @Test
+    fun `모서리 블록은 5개의 주변 블록을 가진다`() {
+        val point = Point(1, 0)
+
+        assertThat(point.getNearPoints().size).isEqualTo(5)
+    }
+
+    @Test
+    fun `완전히 둘러쌓인 블록은 8개의 주변 블록을 가진다`() {
+        val point = Point(1, 1)
+
+        assertThat(point.getNearPoints().size).isEqualTo(8)
+    }
 }

src/test/kotlin/minesweeper/domain/SafeBlockTest.kt

@@ -0,0 +1,35 @@
+package minesweeper.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
+
+class SafeBlockTest {
+
+    @Test
+    fun `0보다 작은 수는 생성될 수 없다`() {
+        val exception = org.junit.jupiter.api.assertThrows<MineSweeperException> {
+            SafeBlock(-1)
+        }
+
+        assertThat(exception.reason).isEqualTo(ExceptionReason.ILLEGAL_NEAR_MINE_RANGE)
+    }
+
+    @DisplayName("블록 생성 테스트")
+    @ParameterizedTest(name = "{0}는 생성된다")
+    @ValueSource(ints = [0, 1, 2, 3, 4, 5, 6, 7, 8])
+    fun `0~8 까지 들어갈 수 있다`(nearMineCount: Int) {
+        assertThat(SafeBlock(nearMineCount)).isExactlyInstanceOf(SafeBlock::class.java)
+    }
+
+    @Test
+    fun `8보다 큰 수는 생성될 수 없다`() {
+        val exception = org.junit.jupiter.api.assertThrows<MineSweeperException> {
+            SafeBlock(9)
+        }
+
+        assertThat(exception.reason).isEqualTo(ExceptionReason.ILLEGAL_NEAR_MINE_RANGE)
+    }
+}

src/test/kotlin/minesweeper/view/FakeInputView.kt

@@ -0,0 +1,9 @@
+package minesweeper.view
+
+class FakeInputView(private val height: Int, private val width: Int, private val mineCount: Int) : InputView {
+    override fun readHeight(): Int = height
+
+    override fun readWidth(): Int = width
+
+    override fun readMineCount(): Int = mineCount
+}