[Step2]: 🚀 2단계 - 지뢰 찾기(지뢰 개수)

src/main/kotlin/mineswipper/MineGame.kt

@@ -1,7 +1,7 @@
 package mineswipper
 
-import mineswipper.domain.map.Field
-import mineswipper.domain.map.Size
+import mineswipper.domain.map.position.Size
+import mineswipper.domain.map.util.FieldFactory
 import mineswipper.domain.map.util.PositionFactory
 import mineswipper.domain.map.util.RandomMinePositionGenerator
 import mineswipper.ui.InputManager
@@ -17,10 +17,7 @@ class MineGame(
         val width = inputManager.inputWidth()
         val size = Size(width, height)
         val mine = inputManager.inputMine()
-        val field = Field(
-            size,
-            positionFactory.generateMinePositions(size, mine)
-        )
+        val field = FieldFactory(size).createField(positionFactory.generateMinePositions(size, mine))
 
         outputManager.printStartGame()
         outputManager.printField(field)

src/main/kotlin/mineswipper/domain/map/Field.kt

@@ -1,32 +1,28 @@
 package mineswipper.domain.map
 
+import mineswipper.domain.map.position.Position
+import mineswipper.domain.map.position.Row
+import mineswipper.domain.map.position.Size
+
 class Field(
-    private val size: Size,
-    positions: List<Position>
+    val field: Map<Row, Pedals>
 ) {
-    val field: Map<Int, Pedals>
+    fun findPedal(position: Position): Pedal {
+        val pedals = field[position.toRow()]
+        require(pedals != null) { VALID_MESSAGE }
 
-    init {
-        val initField: MutableMap<Int, Pedals> = mutableMapOf()
-        repeat(size.height) { x ->
-            initField[x] = pedalSetting(x, positions)
-        }
-        field = initField.toMap()
+        return pedals.get(position.x)
     }
 
-    private fun pedalSetting(x: Int, positions: List<Position>): Pedals {
-        val pedalList = (0 until size.width).map { y ->
-            val position = Position(x, y)
-            createPedal(positions, position)
-        }
-        return Pedals(pedalList)
+    fun getSize(): Size {
+        val pedals = field[Row(FIRST_ROW_FOR_SIZE)]
+        require(pedals != null) { VALID_MESSAGE }
+
+        return Size(field.size, pedals.value.size)
     }
 
-    private fun createPedal(
-        positions: List<Position>,
-        position: Position
-    ) = when (positions.contains(position)) {
-        true -> Mine()
-        false -> NormalPedal()
+    companion object {
+        private const val VALID_MESSAGE: String = "해당 위치에 값이 존재하지 않습니다."
+        private const val FIRST_ROW_FOR_SIZE: Int = 0
     }
 }

src/main/kotlin/mineswipper/domain/map/Mark.kt

@@ -0,0 +1,6 @@
+package mineswipper.domain.map
+
+@JvmInline
+value class Mark(
+    val value: String
+)

src/main/kotlin/mineswipper/domain/map/Mine.kt

@@ -1,3 +1,5 @@
 package mineswipper.domain.map
 
-class Mine : Pedal
+class Mine(
+    override var mark: Mark? = Mark("*")
+) : Pedal

src/main/kotlin/mineswipper/domain/map/NormalPedal.kt

@@ -1,3 +1,5 @@
 package mineswipper.domain.map
 
-class NormalPedal : Pedal
+class NormalPedal(
+    override var mark: Mark? = null
+) : Pedal

src/main/kotlin/mineswipper/domain/map/Pedal.kt

@@ -1,4 +1,5 @@
 package mineswipper.domain.map
 
 sealed interface Pedal {
-}
+    var mark: Mark?
+}

src/main/kotlin/mineswipper/domain/map/Pedals.kt

@@ -3,4 +3,15 @@ package mineswipper.domain.map
 @JvmInline
 value class Pedals(
     val value: List<Pedal>
-)
+) {
+    fun get(index: Int): Pedal {
+        val result = value.getOrNull(index)
+        require(result != null) { ERROR_MESSAGE }
+        return result
+    }
+
+    companion object {
+        private const val ERROR_MESSAGE: String = "해당 인덱스에 값이 존재하지 않습니다."
+    }
+}
+

src/main/kotlin/mineswipper/domain/map/position/Position.kt

@@ -0,0 +1,22 @@
+package mineswipper.domain.map.position
+
+data class Position(
+    val x: Int,
+    val y: Int
+) {
+    fun getAroundPositions(size: Size): Positions {
+        return (x - 1..x + 1).flatMap { xVal ->
+            (y - 1..y + 1).map { yVal -> Position(xVal, yVal) }
+        }.filter { it.isValid(size.width, size.height) && it != this }.toPositions()
+    }
+
+    fun toRow(): Row {
+        return Row(y)
+    }
+
+    private fun isValid(width: Int, height: Int): Boolean {
+        return x in 0 until width && y in 0 until height
+    }
+}
+
+fun List<Position>.toPositions(): Positions = Positions(this)

src/main/kotlin/mineswipper/domain/map/position/Positions.kt

@@ -0,0 +1,9 @@
+package mineswipper.domain.map.position
+
+data class Positions(
+    val positions: List<Position>
+) {
+    fun contains(position: Position): Boolean {
+        return positions.contains(position)
+    }
+}

src/main/kotlin/mineswipper/domain/map/position/Row.kt

@@ -0,0 +1,4 @@
+package mineswipper.domain.map.position
+
+@JvmInline
+value class Row(val value: Int)

src/main/kotlin/mineswipper/domain/map/Size.kt → src/main/kotlin/mineswipper/domain/map/position/Size.kt

@@ -1,4 +1,4 @@
-package mineswipper.domain.map
+package mineswipper.domain.map.position
 
 data class Size(
     val width: Int,

src/main/kotlin/mineswipper/domain/map/util/FieldFactory.kt

@@ -0,0 +1,45 @@
+package mineswipper.domain.map.util
+
+import mineswipper.domain.map.Field
+import mineswipper.domain.map.Mine
+import mineswipper.domain.map.NormalPedal
+import mineswipper.domain.map.Pedal
+import mineswipper.domain.map.Pedals
+import mineswipper.domain.map.position.Position
+import mineswipper.domain.map.position.Positions
+import mineswipper.domain.map.position.Row
+import mineswipper.domain.map.position.Size
+
+class FieldFactory(
+    private val size: Size
+) {
+    fun createField(
+//        size: Size,
+        minePositions: Positions
+    ): Field {
+        val initField: MutableMap<Row, Pedals> = mutableMapOf()
+        repeat(size.height) { x ->
+            initField[Row(x)] = pedalSetting(x, minePositions)
+        }
+
+        val fakeField = Field(initField.toMap())
+
+        MarkGenerator.markGeneration(fakeField)
+
+        return fakeField
+    }
+    private fun createPedal(
+        minePositions: Positions,
+        position: Position
+    ): Pedal {
+        return if (minePositions.contains(position)) Mine() else NormalPedal()
+    }
+
+    private fun pedalSetting(x: Int, minePositions: Positions): Pedals {
+        val pedalList = (0 until size.width).map { y ->
+            val position = Position(x, y)
+            createPedal(minePositions, position)
+        }
+        return Pedals(pedalList)
+    }
+}

src/main/kotlin/mineswipper/domain/map/util/MarkGenerator.kt

@@ -0,0 +1,28 @@
+package mineswipper.domain.map.util
+
+import mineswipper.domain.map.Field
+import mineswipper.domain.map.Mark
+import mineswipper.domain.map.Mine
+import mineswipper.domain.map.position.Position
+
+object MarkGenerator {
+    fun markGeneration(field: Field, position: Position = Position(0, 0)): Mark {
+        val pedal = field.findPedal(position)
+        if (pedal.mark != null) return pedal.mark!!
+
+        val aroundPositions = position.getAroundPositions(field.getSize())
+        val count = aroundPositions.positions.count {
+            val findPedal = field.findPedal(it)
+            findPedal is Mine
+        }
+
+        val mark = Mark(count.toString())
+        pedal.mark = mark
+
+        aroundPositions.positions.forEach {
+            markGeneration(field, it)
+        }
+
+        return mark
+    }
+}

src/main/kotlin/mineswipper/domain/map/util/MinePositionStrategy.kt

@@ -1,8 +1,8 @@
 package mineswipper.domain.map.util
 
-import mineswipper.domain.map.Position
-import mineswipper.domain.map.Size
+import mineswipper.domain.map.position.Positions
+import mineswipper.domain.map.position.Size
 
 interface MinePositionStrategy {
-    fun createMinePosition(size: Size, mineAmount: Int): List<Position>
-}
+    fun createMinePosition(size: Size, mineAmount: Int): Positions
+}

src/main/kotlin/mineswipper/domain/map/util/PositionFactory.kt

@@ -1,21 +1,12 @@
 package mineswipper.domain.map.util
 
-import mineswipper.domain.map.Position
-import mineswipper.domain.map.Size
+import mineswipper.domain.map.position.Positions
+import mineswipper.domain.map.position.Size
 
 class PositionFactory(
     private val minePositionStrategy: MinePositionStrategy
 ) {
-
-    fun generateMinePositions(height: Int, width: Int, mineAmount: Int): List<Position> {
-        return (0 until  mineAmount).map {
-            val x = (0 until height).random()
-            val y = (0 until width).random()
-            Position(x, y)
-        }
-    }
-
-    fun generateMinePositions(size: Size, mineAmount: Int): List<Position> {
+    fun generateMinePositions(size: Size, mineAmount: Int): Positions {
         require(size.width >= mineAmount && size.height >= mineAmount) { MINE_AMOUNT_VALID_MESSAGE }
 
         return minePositionStrategy.createMinePosition(size, mineAmount)

src/main/kotlin/mineswipper/domain/map/util/RandomMinePositionGenerator.kt

@@ -1,10 +1,11 @@
 package mineswipper.domain.map.util
 
-import mineswipper.domain.map.Position
-import mineswipper.domain.map.Size
+import mineswipper.domain.map.position.Position
+import mineswipper.domain.map.position.Positions
+import mineswipper.domain.map.position.Size
 
 class RandomMinePositionGenerator : MinePositionStrategy {
-    override fun createMinePosition(size: Size, mineAmount: Int): List<Position> {
+    override fun createMinePosition(size: Size, mineAmount: Int): Positions {
         val positions = mutableSetOf<Position>()
 
         while (positions.size < mineAmount) {
@@ -13,6 +14,6 @@ class RandomMinePositionGenerator : MinePositionStrategy {
             positions.add(Position(x, y))
         }
 
-        return positions.toList()
+        return Positions(positions.toList())
     }
 }

src/main/kotlin/mineswipper/ui/OutputManager.kt

@@ -16,7 +16,7 @@ class OutputManager {
     private fun printWidth(pedals: Pedals) {
         val pedal = pedals.value.joinToString(" ") {
             when (it) {
-                is NormalPedal -> NORMAL_PEDAL
+                is NormalPedal -> it.mark?.value ?: "0"
                 is Mine -> MINE_PEDAL
             }
         }
@@ -29,7 +29,6 @@ class OutputManager {
     }
 
     companion object {
-        private const val NORMAL_PEDAL: String = "c"
         private const val MINE_PEDAL: String = "*"
         private const val START_GAME: String = "지뢰찾기 게임 시작"
     }

src/test/kotlin/mineswipper/domain/map/FieldTest.kt

@@ -0,0 +1,34 @@
+package mineswipper.domain.map
+
+import io.kotest.matchers.types.shouldBeInstanceOf
+import mineswipper.domain.map.position.Position
+import mineswipper.domain.map.position.Positions
+import mineswipper.domain.map.position.Size
+import mineswipper.domain.map.util.FieldFactory
+import mineswipper.domain.map.util.MinePositionStrategy
+import org.junit.jupiter.api.Test
+
+class FieldTest {
+
+    @Test
+    fun `필드에는 지뢰 발판이 있다`() {
+        val size = Size(2, 2)
+        val mine = 2
+        val field = FieldFactory(size).createField(
+            MineMarkTestStrategy().createMinePosition(size, mine)
+        )
+
+        field.findPedal(Position(1, 0)).shouldBeInstanceOf<Mine>()
+    }
+}
+
+class MineMarkTestStrategy : MinePositionStrategy {
+    override fun createMinePosition(size: Size, mineAmount: Int): Positions {
+        return Positions(
+            listOf(
+                Position(1, 0),
+                Position(0, 1)
+            )
+        )
+    }
+}