[🚀 3단계 - 지뢰 찾기(게임 실행)] 신종화 미션 제출합니다.

README.md

@@ -44,3 +44,27 @@
 
 - 필드 (Field)
     - [x] 필드의 각 SafeSpot에 대해 주변에 있는 지뢰의 개수를 계산한다.
+
+## 🚀 3단계 - 지뢰 찾기(게임 실행)
+
+### 기능 요구 사항
+
+- 게임을 시작하면 지뢰를 찾는 게임이 시작된다.
+- 좌표를 선택해 해당 좌표에 지뢰가 있는지 확인한다.
+- 선택한 좌표 중심으로 지뢰가 없는 인접한 칸이 모두 열리게 된다.
+
+### 기능 구현 목록
+
+- 스팟 (Spot)
+    - [x] 스팟의 상태를 가지고 있다.
+    - [x] 스팟을 열 수 있다.
+    - [x] 스팟이 열려 있는지 여부를 확인할 수 있다.
+
+- 지뢰 찾기 게임 (MinesweeperGame)
+    - [x] 좌표를 입력 받아 해당 좌표에 지뢰가 있는지 확인할 수 있다.
+    - [x] 선택한 좌표 중심으로 지뢰가 없는 인접한 칸이 모두 열리게 된다.
+    - [x] 입력 받은 좌표에 지뢰가 있는 경우 게임이 종료된다.
+
+- 필드 (field)
+    - [x] 필드의 특정 위치를 오픈할 수 있다.
+        - [x] 해당 필드에 인접한 지뢰 수가 0이면 인접한 모든 필드를 오픈한다.

src/main/kotlin/minesweeper/MineSweeperApplication.kt

@@ -3,7 +3,7 @@ package minesweeper
 import minesweeper.controller.MinesweeperController
 import minesweeper.domain.FieldInfo
 import minesweeper.infrastructure.ConsoleMinesweeperInputAdapter
-import minesweeper.infrastructure.RandomSpotGenerator
+import minesweeper.infrastructure.RandomMinePositionSelector
 import minesweeper.view.InputVIew
 import minesweeper.view.OutputView
 
@@ -12,12 +12,12 @@ fun main() {
     val outputView = OutputView()
     val consoleMinesweeperInputAdapter = ConsoleMinesweeperInputAdapter(inputVIew)
 
-    val controller = MinesweeperController(consoleMinesweeperInputAdapter, outputView, RandomSpotGenerator())
+    val controller = MinesweeperController(consoleMinesweeperInputAdapter, outputView, RandomMinePositionSelector())
 
     val fieldInfo = FieldInfo(controller.getFieldHeight(), controller.getFieldWidth())
     val mineCount = controller.getMineCount()
 
-    val field = controller.createNewField(fieldInfo, mineCount)
+    val field = controller.makeNewField(fieldInfo, mineCount)
 
-    controller.announceInitialField(field)
+    controller.playGame(field)
 }

src/main/kotlin/minesweeper/adapter/MinesweeperInputAdapter.kt

@@ -3,11 +3,14 @@ package minesweeper.adapter
 import minesweeper.domain.FieldHeight
 import minesweeper.domain.FieldWidth
 import minesweeper.domain.MineCount
+import minesweeper.domain.Position
 
 interface MinesweeperInputAdapter {
     fun fetchFieldWidth(): FieldWidth
 
     fun fetchFieldHeight(): FieldHeight
 
     fun fetchMineCount(): MineCount
+
+    fun fetchOpenAttemptPosition(): Position
 }

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

@@ -6,14 +6,16 @@ import minesweeper.domain.FieldHeight
 import minesweeper.domain.FieldInfo
 import minesweeper.domain.FieldWidth
 import minesweeper.domain.MineCount
-import minesweeper.domain.SpotGenerator
+import minesweeper.domain.MinePositionSelector
+import minesweeper.domain.OpenResult
+import minesweeper.domain.Position
 import minesweeper.dto.FieldResponse
 import minesweeper.view.OutputView
 
 class MinesweeperController(
     private val inputAdapter: MinesweeperInputAdapter,
     private val outputView: OutputView,
-    private val spotGenerator: SpotGenerator,
+    private val minePositionSelector: MinePositionSelector,
 ) {
     fun getFieldWidth(): FieldWidth {
         return inputAdapter.fetchFieldWidth()
@@ -27,14 +29,38 @@ class MinesweeperController(
         return inputAdapter.fetchMineCount()
     }
 
-    fun announceInitialField(field: Field) {
-        outputView.printInitialField(FieldResponse(field))
-    }
-
-    fun createNewField(
+    fun makeNewField(
         fieldInfo: FieldInfo,
         mineCount: MineCount,
     ): Field {
-        return Field(fieldInfo, mineCount, spotGenerator)
+        return Field(fieldInfo, minePositionSelector.generate(fieldInfo, mineCount))
+    }
+
+    fun playGame(field: Field) {
+        outputView.printStartGameMessage()
+        while (true) {
+            if (doOpen(field)) return
+        }
+    }
+
+    private fun doOpen(field: Field): Boolean {
+        val openResult = field.openSpot(getOpenAttemptPosition())
+        when (openResult) {
+            is OpenResult.GameOver -> {
+                outputView.printGameLoseMessage()
+                return true
+            }
+            is OpenResult.Success -> {
+                outputView.printField(FieldResponse(field))
+            }
+            OpenResult.AlreadyOpened -> {
+                outputView.printAlreadyOpenedMessage(FieldResponse(field))
+            }
+        }
+        return false
+    }
+
+    private fun getOpenAttemptPosition(): Position {
+        return inputAdapter.fetchOpenAttemptPosition()
     }
 }

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

@@ -2,63 +2,68 @@ package minesweeper.domain
 
 class Field(
     private val fieldInfo: FieldInfo,
-    private val mineCount: MineCount,
-    private val spotGenerator: SpotGenerator,
+    private val minePositions: Set<Position>,
 ) {
-    private val width = fieldInfo.getWidth()
-    val lines: List<FieldLine> = createField()
+    private val spots: Map<Position, Spot> = createField()
 
     init {
         validateMineCount()
     }
 
-    private fun createField(): List<FieldLine> {
-        val spots = spotGenerator.generate(fieldInfo, mineCount)
-        return spots.mapIndexed { index, spot ->
-            if (spot is SafeSpot) {
-                val y = index / width
-                val x = index % width
-                val nearbyMineCount = countAdjacentMines(spots, y, x)
-                spot.updateNearbyMineCount(nearbyMineCount)
+    private fun createField(): Map<Position, Spot> {
+        return (0 until fieldInfo.getWidth() + 1).flatMap { x ->
+            (0 until fieldInfo.getHeight() + 1).map { y ->
+                Position(x, y)
+            }
+        }.associateWith { position ->
+            when {
+                minePositions.contains(position) -> MineSpot(position)
+                else -> SafeSpot(position)
             }
-            spot
-        }.chunked(width).map { lineSpots ->
-            FieldLine(lineSpots)
         }
     }
 
-    private fun countAdjacentMines(
-        spots: List<Spot>,
-        y: Int,
-        x: Int,
-    ): Int {
-        return NEARBY.count { (dy, dx) ->
-            val newY = y + dy
-            val newX = x + dx
-            isWithinBounds(newY, newX) && spots[newY * width + newX].isMine()
-        }
+    fun getFieldInfo(): FieldInfo {
+        return fieldInfo
     }
 
-    private fun isWithinBounds(
-        y: Int,
-        x: Int,
-    ): Boolean {
-        return y in 0 until fieldInfo.getHeight() && x in 0 until width
+    fun getSpot(position: Position): Spot {
+        return spots[position] ?: throw IllegalArgumentException("해당 위치에 대한 Spot이 존재하지 않습니다.")
     }
 
     private fun validateMineCount() {
-        val height = fieldInfo.getHeight()
-        val totalSpots = height * width
-        require(mineCount.count <= totalSpots) { "지뢰 개수는 필드의 총 스팟보다 많을 수 없습니다." }
+        val totalPossibleSpots = fieldInfo.getHeight() * fieldInfo.getWidth()
+        require(minePositions.size <= totalPossibleSpots) { "지뢰 개수는 필드의 총 스팟보다 많을 수 없습니다." }
     }
 
-    companion object {
-        private val NEARBY =
-            listOf(
-                Pair(-1, 0),
-                Pair(0, -1),
-                Pair(0, 1),
-                Pair(1, 0),
-            )
+    fun openSpot(position: Position): OpenResult {
+        val targetSpot =
+            spots[position]?.let {
+                if (it.isMine()) {
+                    return OpenResult.GameOver
+                }
+                it
+            } as SafeSpot
+        val openResult = targetSpot.open()
+        targetSpot.calculateNearbyMineCount(minePositions)
+        checkAndOpenNearbySpot(targetSpot)
+        return openResult
+    }
+
+    private fun checkAndOpenNearbySpot(targetSpot: SafeSpot) {
+        if (targetSpot.nearbyMineCount == 0) {
+            openNearbySpots(targetSpot.position)
+        }
+    }
+
+    private fun openNearbySpots(position: Position) {
+        val nearbyPositions = position.nearbyPositions()
+        nearbyPositions.forEach {
+            spots[it]?.let { spot ->
+                if (!spot.isOpened()) {
+                    openSpot(it)
+                }
+            }
+        }
     }
 }

src/main/kotlin/minesweeper/domain/SpotGenerator.kt → src/main/kotlin/minesweeper/domain/MinePositionSelector.kt

@@ -1,8 +1,8 @@
 package minesweeper.domain
 
-fun interface SpotGenerator {
+fun interface MinePositionSelector {
     fun generate(
         fieldInfo: FieldInfo,
         mineCount: MineCount,
-    ): List<Spot>
+    ): Set<Position>
 }

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

@@ -0,0 +1,21 @@
+package minesweeper.domain
+
+enum class NearbyDirection(private val coordinate: Position) {
+    UP(Position(0, -1)),
+    DOWN(Position(0, 1)),
+    LEFT(Position(-1, 0)),
+    RIGHT(Position(1, 0)),
+    UP_LEFT(Position(-1, -1)),
+    UP_RIGHT(Position(1, -1)),
+    DOWN_LEFT(Position(-1, 1)),
+    DOWN_RIGHT(Position(1, 1)),
+    ;
+
+    fun dx(): Int {
+        return coordinate.x
+    }
+
+    fun dy(): Int {
+        return coordinate.y
+    }
+}

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

@@ -0,0 +1,12 @@
+package minesweeper.domain
+
+data class Position(val x: Int, val y: Int) {
+    fun nearbyPositions(): Set<Position> {
+        return NearbyDirection.entries.map { direction ->
+            Position(
+                x + direction.dx(),
+                y + direction.dy(),
+            )
+        }.toSet()
+    }
+}

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

@@ -1,5 +1,46 @@
 package minesweeper.domain
 
-abstract class Spot(private val y: Int, private val x: Int) {
+sealed interface OpenResult {
+    data object Success : OpenResult
+
+    data object AlreadyOpened : OpenResult
+
+    data object GameOver : OpenResult
+}
+
+sealed class Spot(val position: Position) {
+    private var isOpened = false
+
+    fun open(): OpenResult {
+        if (isOpened) {
+            return OpenResult.AlreadyOpened
+        }
+        isOpened = true
+        return OpenResult.Success
+    }
+
+    fun isOpened(): Boolean {
+        return isOpened
+    }
+
     abstract fun isMine(): Boolean
 }
+
+class SafeSpot(position: Position) : Spot(position) {
+    var nearbyMineCount: Int = 0
+
+    override fun isMine(): Boolean {
+        return false
+    }
+
+    fun calculateNearbyMineCount(minePositions: Set<Position>) {
+        val nearbyPositions = position.nearbyPositions()
+        this.nearbyMineCount = nearbyPositions.count { it in minePositions }
+    }
+}
+
+class MineSpot(position: Position) : Spot(position) {
+    override fun isMine(): Boolean {
+        return true
+    }
+}