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

src/main/kotlin/mineswipper/MineGame.kt

@@ -1,7 +1,8 @@
 package mineswipper
 
 import mineswipper.domain.map.Field
-import mineswipper.domain.map.Size
+import mineswipper.domain.map.position.Size
+import mineswipper.domain.map.util.MarkGenerator
 import mineswipper.domain.map.util.PositionFactory
 import mineswipper.domain.map.util.RandomMinePositionGenerator
 import mineswipper.ui.InputManager
@@ -22,6 +23,8 @@ class MineGame(
             positionFactory.generateMinePositions(size, mine)
         )
 
+        MarkGenerator.markGeneration(field)
+
         outputManager.printStartGame()
         outputManager.printField(field)
     }

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

@@ -1,32 +1,49 @@
 package mineswipper.domain.map
 
+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 Field(
-    private val size: Size,
-    positions: List<Position>
+    val size: Size,
+    minePositions: Positions
 ) {
-    val field: Map<Int, Pedals>
+    val field: Map<Row, Pedals>
 
     init {
-        val initField: MutableMap<Int, Pedals> = mutableMapOf()
+        val initField: MutableMap<Row, Pedals> = mutableMapOf()
         repeat(size.height) { x ->
-            initField[x] = pedalSetting(x, positions)
+            initField[Row(x)] = pedalSetting(x, minePositions)
         }
         field = initField.toMap()
     }
 
-    private fun pedalSetting(x: Int, positions: List<Position>): Pedals {
+    private fun pedalSetting(x: Int, minePositions: Positions): Pedals {
         val pedalList = (0 until size.width).map { y ->
             val position = Position(x, y)
-            createPedal(positions, position)
+            createPedal(minePositions, position)
         }
         return Pedals(pedalList)
     }
 
     private fun createPedal(
-        positions: List<Position>,
+        minePositions: Positions,
         position: Position
-    ) = when (positions.contains(position)) {
-        true -> Mine()
-        false -> NormalPedal()
+    ): Pedal {
+        if (minePositions.contains(position)) return Mine()
+        return NormalPedal()
+    }
+
+    fun findPedal(position: Position): Pedal {
+        val pedals = field[position.toRow()]
+        require(pedals != null) { VALID_MESSAGE }
+
+        val pedal = pedals.get(position.x)
+        return pedal
+    }
+
+    companion object {
+        private const val VALID_MESSAGE: String = "오류가 발생했습니다."
     }
 }

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,6 @@
 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,7 @@
 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,8 @@ package mineswipper.domain.map
 @JvmInline
 value class Pedals(
     val value: List<Pedal>
-)
+) {
+    fun get(index: Int): Pedal {
+        return value[index]
+    }
+}

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

@@ -0,0 +1,24 @@
+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/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.size)
+        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,13 @@
 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 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.MinePositionStrategy
+import org.junit.jupiter.api.Test
+
+class FieldTest {
+
+    @Test
+    fun `필드에는 지뢰 발판이 있다`() {
+        val size = Size(2, 2)
+        val mine = 2
+        val field = Field(
+            size,
+            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)
+            )
+        )
+    }
+}

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

@@ -2,6 +2,9 @@ package mineswipper.domain.map
 
 import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.matchers.shouldBe
+import mineswipper.domain.map.position.Position
+import mineswipper.domain.map.position.Positions
+import mineswipper.domain.map.position.Size
 import mineswipper.domain.map.util.MinePositionStrategy
 import mineswipper.domain.map.util.PositionFactory
 import org.junit.jupiter.api.Test
@@ -15,16 +18,13 @@ class PositionFactoryTest {
         val width = 10
         val mineAmount = 10
 
-        val positions: List<Position> = positionFactory.generateMinePositions(
+        val positions: Positions = positionFactory.generateMinePositions(
             Size(width, height),
             mineAmount
         )
 
-        positions.containsAll(
-            listOf(
-                Position(1, 1),
-                Position(2, 2)
-            )
+        positions.contains(
+            Position(1, 1)
         ) shouldBe true
     }
 
@@ -40,10 +40,12 @@ class PositionFactoryTest {
 }
 
 class TestStrategy : MinePositionStrategy {
-    override fun createMinePosition(size: Size, mineAmount: Int): List<Position> {
-        return listOf(
-            Position(1, 1),
-            Position(2, 2)
+    override fun createMinePosition(size: Size, mineAmount: Int): Positions {
+        return Positions(
+            listOf(
+                Position(1, 1),
+                Position(2, 2)
+            )
         )
     }
 }

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

@@ -1,6 +1,7 @@
 package mineswipper.domain.map
 
 import io.kotest.matchers.shouldBe
+import mineswipper.domain.map.position.Size
 import org.junit.jupiter.api.Test
 
 class SizeTest {