[Step1] 지뢰 찾기(그리기)

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.2.3")
+    testImplementation("io.kotest", "kotest-runner-junit5", "5.6.1")
 }
 
 tasks {

src/main/kotlin/MineSweeperApplication.kt

@@ -0,0 +1,5 @@
+import controller.MineSweeperController
+
+fun main() {
+    MineSweeperController().start()
+}

src/main/kotlin/README.md

@@ -0,0 +1,20 @@
+# 지뢰 찾기
+
+## 기능 요구사항
+
+- 지뢰 찾기를 변형한 프로그램을 구현한다.
+
+- 높이와 너비, 지뢰 개수를 입력받을 수 있다.
+- 지뢰는 눈에 잘 띄는 것으로 표기한다.
+- 지뢰는 가급적 랜덤에 가깝게 배치한다.
+
+## 기능 목록
+
+[x] 정해진 높이와 너비 내에서 랜덤으로 지뢰 위치를 지정할 수 있다.
+[x] 지뢰 위치 정보에 맞는 지뢰판을 생성할 수 있다.
+[x] 정해진 높이와 너비 내의 지뢰판을 생성할 수 있다.
+
+## 책임
+
+1. 지뢰를 배치해라 -> `landMineGenerator.generate()`
+2. 랜덤으로 지뢰 위치를 결정하라 -> `MineLocationStrategy.locations()`

src/main/kotlin/controller/MineSweeperController.kt

@@ -0,0 +1,20 @@
+package controller
+
+import domain.MineBoard
+import view.InputView
+import view.OutputView
+
+class MineSweeperController(
+    private val inputView: InputView = InputView,
+    private val outputView: OutputView = OutputView
+) {
+
+    fun start() {
+        val boardSize = inputView.requestBoardSize()
+        val mineCount = inputView.requestCountOfMine()
+
+        outputView.printStartGame()
+        val mineBoard = MineBoard(boardSize, mineCount)
+        outputView.printMineBoard(mineBoard)
+    }
+}

src/main/kotlin/domain/BoardInfo.kt

@@ -0,0 +1,8 @@
+package domain
+
+const val NON_MINE = 'C'
+const val MINE = '*'
+
+data class BoardInfo(
+    val values: List<List<Cell>>
+)

src/main/kotlin/domain/BoardInfoGenerator.kt

@@ -0,0 +1,27 @@
+package domain
+
+class BoardInfoGenerator(
+    private val boardSize: BoardSize,
+    mineCount: Int,
+    mineLocationStrategy: MineLocationStrategy = RandomMineLocationStrategy()
+) {
+    private val mineLocations = mineLocationStrategy.generateMineLocations(boardSize, mineCount)
+
+    fun generate(): BoardInfo {
+        val board = initBoard()
+
+        for (i in 0 until boardSize.height) {
+            for (j in 0 until boardSize.width) {
+                if (mineLocations.contains(Point(i, j))) {
+                    board[i][j] = Cell(MINE)
+                }
+            }
+        }
+
+        return BoardInfo(board.map { it.toList() })
+    }
+
+    private fun initBoard(): Array<Array<Cell>> {
+        return Array(boardSize.width) { Array(boardSize.height) { Cell(NON_MINE) } }
+    }
+}

src/main/kotlin/domain/BoardSize.kt

@@ -0,0 +1,9 @@
+package domain
+
+data class BoardSize(
+    val width: Int,
+    val height: Int
+) {
+    val area: Int
+        get() = width * height
+}

src/main/kotlin/domain/Cell.kt

@@ -0,0 +1,5 @@
+package domain
+
+data class Cell(
+    val value: Char
+)

src/main/kotlin/domain/MineBoard.kt

@@ -0,0 +1,17 @@
+package domain
+
+data class MineBoard(
+    val boardSize: BoardSize,
+    val mineCount: Int,
+    val boardInfoGenerator: BoardInfoGenerator = BoardInfoGenerator(boardSize, mineCount)
+) {
+    val info: BoardInfo by lazy {
+        boardInfoGenerator.generate()
+    }
+
+    init {
+        require(boardSize.area >= mineCount) {
+            "지뢰판의 크기보다 지뢰의 개수가 더 많습니다. [지뢰 개수: $mineCount]"
+        }
+    }
+}

src/main/kotlin/domain/MineLocationStrategy.kt

@@ -0,0 +1,5 @@
+package domain
+
+interface MineLocationStrategy {
+    fun generateMineLocations(boardSize: BoardSize, mineCount: Int): MineLocations
+}

src/main/kotlin/domain/MineLocations.kt

@@ -0,0 +1,11 @@
+package domain
+
+data class MineLocations(
+    val points: List<Point>
+) {
+    constructor(vararg point: Point) : this(points = point.toList())
+
+    fun contains(point: Point): Boolean {
+        return points.contains(point)
+    }
+}

src/main/kotlin/domain/Point.kt

@@ -0,0 +1,6 @@
+package domain
+
+data class Point(
+    val y: Int,
+    val x: Int
+)

src/main/kotlin/domain/RandomMineLocationStrategy.kt

@@ -0,0 +1,13 @@
+package domain
+
+class RandomMineLocationStrategy : MineLocationStrategy {
+    override fun generateMineLocations(boardSize: BoardSize, mineCount: Int): MineLocations {
+        return MineLocations(List(mineCount) { randomPoint(boardSize) })
+    }
+
+    private fun randomPoint(boardSize: BoardSize): Point {
+        val randomY = (1 until boardSize.height).random()
+        val randomX = (0 until boardSize.width).random()
+        return Point(randomY, randomX)
+    }
+}

src/main/kotlin/view/InputView.kt

@@ -0,0 +1,28 @@
+package view
+
+import domain.BoardSize
+
+object InputView {
+    fun requestBoardSize(): BoardSize {
+        val height = requestHeight()
+        val width = requestWidth()
+
+        return BoardSize(width, height)
+    }
+
+    private fun requestHeight(): Int {
+        println("높이를 입력하세요.")
+        return readln().toInt()
+    }
+
+    private fun requestWidth(): Int {
+        println("\n너비를 입력하세요.")
+        return readln().toInt()
+    }
+
+    fun requestCountOfMine(): Int {
+        println("\n지뢰는 몇 개인가요?")
+
+        return readln().toInt()
+    }
+}

src/main/kotlin/view/OutputView.kt

@@ -0,0 +1,16 @@
+package view
+
+import domain.MineBoard
+
+object OutputView {
+    fun printStartGame() {
+        println()
+        println("지뢰찾기 게임 시작")
+    }
+
+    fun printMineBoard(mineBoard: MineBoard) {
+        mineBoard.info.values.forEach { cell ->
+            println(cell.map { it.value }.joinToString(" "))
+        }
+    }
+}

src/test/kotlin/domain/FixedMineLocationStrategy.kt

@@ -0,0 +1,12 @@
+package domain
+
+class FixedMineLocationStrategy(
+    private val mineLocations: MineLocations
+) : MineLocationStrategy {
+    override fun generateMineLocations(boardSize: BoardSize, mineCount: Int): MineLocations {
+        require(boardSize.area >= mineCount) {
+            "지뢰판의 크기보다 지뢰의 개수가 더 많습니다. [지뢰 개수: $mineCount]"
+        }
+        return mineLocations
+    }
+}

src/test/kotlin/domain/MineBoardGeneratorTest.kt

@@ -0,0 +1,50 @@
+package domain
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.inspectors.forAll
+import io.kotest.matchers.shouldBe
+
+class MineBoardGeneratorTest : FunSpec({
+    test("지뢰 위치 정보에 맞는 지뢰판을 생성할 수 있다.") {
+        // given
+        val width = 5
+        val height = 5
+        val boardSize = BoardSize(width, height)
+        val mineCount = 3
+        val mineLocations = MineLocations(Point(1, 1), Point(1, 2))
+        val boardInfoGenerator = BoardInfoGenerator(
+            boardSize,
+            mineCount,
+            FixedMineLocationStrategy(mineLocations)
+        )
+
+        // when
+        val actual = boardInfoGenerator.generate()
+
+        // then
+        mineLocations.points.forAll {
+            actual.values[it.y][it.x].value shouldBe MINE
+        }
+    }
+
+    test("정해진 높이와 너비 내의 지뢰판을 생성할 수 있다.") {
+        // given
+        val width = 5
+        val height = 5
+        val boardSize = BoardSize(width, height)
+        val mineCount = 3
+        val boardInfoGenerator = BoardInfoGenerator(
+            boardSize,
+            mineCount,
+        )
+
+        // when
+        val actual = boardInfoGenerator.generate()
+
+        // then
+        actual.values.size shouldBe width
+        actual.values.forAll {
+            it.size shouldBe height
+        }
+    }
+})

src/test/kotlin/domain/MineBoardTest.kt

@@ -0,0 +1,18 @@
+package domain
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+
+class MineBoardTest : FunSpec({
+
+    test("지뢰판 사이즈보다 많은 지뢰 개수가 들어올 경우 예외가 발생한다.") {
+        // given
+        val boardSize = BoardSize(5, 5)
+        val mineCount = 100
+
+        // when, then
+        shouldThrow<IllegalArgumentException> { MineBoard(boardSize, mineCount) }
+            .also { it.message shouldBe "지뢰판의 크기보다 지뢰의 개수가 더 많습니다. [지뢰 개수: $mineCount]" }
+    }
+})

src/test/kotlin/domain/RandomMineLocationStrategyTest.kt

@@ -0,0 +1,26 @@
+package domain
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.inspectors.forAll
+import io.kotest.matchers.ints.shouldBeInRange
+
+class RandomMineLocationStrategyTest : FunSpec({
+
+    test("정해진 높이와 너비 내에서 랜덤으로 지뢰 위치를 지정할 수 있다.") {
+        // given
+        val strategy = RandomMineLocationStrategy()
+        val width = 5
+        val height = 5
+        val boardSize = BoardSize(width, height)
+        val mineCount = 3
+
+        // when
+        val actual = strategy.generateMineLocations(boardSize, mineCount)
+
+        // then
+        actual.points.forAll {
+            it.x.shouldBeInRange(0 until width)
+            it.y.shouldBeInRange(0 until height)
+        }
+    }
+})