feat: 오목알을 놓은 플레이어가 게임에서 이겼는지 확인하는 기능 구현

docs/README.md

@@ -7,8 +7,9 @@
 - [x] 중복되는 위치의 오목알을 가질 수 없다.
 - [ ] 오목판의 크기는 `15 x 15`이다.
 - [ ] 사용자는 오목알을 놓는다.
-- [ ] 사용자는 게임에서 이겼는지 확인한다.
-- [ ] 사용자는 특정 위치에 돌이 있는지 확인한다.
+- [x] 오목알을 놓은 플레이어가 게임에서 이겼는지 확인한다.
+- [x] 사용자는 특정 위치에 내 돌이 있는지 확인한다.
+- [ ] 특정 위치에 돌을 놓을 수 있는지 판단한다.
 - [ ] 사용자는 마지막 돌의 위치를 알고 있다.
 - [ ] 게임의 진행 여부는 `PlayerState`가 결정한다.
 

src/main/kotlin/Position.kt

@@ -1,12 +1,13 @@
 data class Position(val x: Int, val y: Int) {
  init {
- require(x in MIN_BOUND..MAX_BOUND) { X_OUT_OF_RANGE_ERROR_MESSAGE }
- require(y in MIN_BOUND..MAX_BOUND) { Y_OUT_OF_RANGE_ERROR_MESSAGE }
+ require(x in POSITION_RANGE) { X_OUT_OF_RANGE_ERROR_MESSAGE }
+ require(y in POSITION_RANGE) { Y_OUT_OF_RANGE_ERROR_MESSAGE }
  }
 
  companion object {
- const val MIN_BOUND = 1
- const val MAX_BOUND = 15
+ private const val MIN_BOUND = 1
+ private const val MAX_BOUND = 15
+ val POSITION_RANGE = (MIN_BOUND..MAX_BOUND)
  private const val X_OUT_OF_RANGE_ERROR_MESSAGE = "x의 범위는 ${MIN_BOUND}부터 ${MAX_BOUND}입니다"
  private const val Y_OUT_OF_RANGE_ERROR_MESSAGE = "y의 범위는 ${MIN_BOUND}부터 ${MAX_BOUND}입니다"
  }

src/main/kotlin/Stone.kt

@@ -1,8 +1,9 @@
+import Position.Companion.POSITION_RANGE
+
 class Stone private constructor(val position: Position) {
  companion object {
- private val POSITION_RANGE = (Position.MIN_BOUND..Position.MAX_BOUND)
  private val STONES = POSITION_RANGE.map { x -> POSITION_RANGE.map { y -> Stone(Position(x, y)) } }
 
- fun of(x: Int, y: Int) = STONES[x][y]
+ fun of(x: Int, y: Int) = STONES[x - 1][y - 1]
  }
 }

src/main/kotlin/Stones.kt

@@ -1,11 +1,51 @@
-class Stones(private val stones: List<Stone>) {
+data class Stones(private val stones: List<Stone>) {
  constructor(vararg stones: Stone) : this(stones.toList())
 
  init {
  require(stones.distinct().size == stones.size) { DUPLICATED_ERROR_MESSAGE }
  }
 
+ fun add(newStone: Stone): Stones = Stones(stones + newStone)
+
+ fun hasStone(stone: Stone): Boolean = stones.contains(stone)
+
+ fun checkWin(startStone: Stone): Boolean {
+ val directions = listOf(RIGHT_DIRECTION, TOP_DIRECTION, RIGHT_TOP_DIRECTION, LEFT_BOTTOM_DIRECTION)
+
+ for (moveDirection in directions) {
+ if (checkStraight(startStone.position, moveDirection, FORWARD_WEIGHT)) return true
+ if (checkStraight(startStone.position, moveDirection, BACK_WEIGHT)) return true
+ }
+ return false
+ }
+
+ private fun checkStraight(
+ startPosition: Position,
+ direction: Pair<Int, Int>,
+ weight: Int = FORWARD_WEIGHT
+ ): Boolean {
+ val (startX, startY) = Pair(startPosition.x, startPosition.y)
+ var count = 1
+ var (currentX, currentY) = Pair(startX + direction.first * weight, startY + direction.second * weight)
+ while (currentX in Position.POSITION_RANGE && currentY in Position.POSITION_RANGE && hasStone(Stone.of(currentX, currentY))) {
+ count++
+ currentX += direction.first * weight
+ currentY += direction.second * weight
+ }
+ if (count >= MINIMUM_WIN_CONDITION) return true
+ return false
+ }
+
  companion object {
  private const val DUPLICATED_ERROR_MESSAGE = "중복되는 위치의 오목알을 가질 수 없습니다."
+ private const val MINIMUM_WIN_CONDITION = 5
+
+ private val RIGHT_DIRECTION = Pair(1, 0)
+ private val TOP_DIRECTION = Pair(0, 1)
+ private val RIGHT_TOP_DIRECTION = Pair(1, 1)
+ private val LEFT_BOTTOM_DIRECTION = Pair(-1, -1)
+
+ private const val FORWARD_WEIGHT = 1
+ private const val BACK_WEIGHT = 1
  }
 }

src/test/kotlin/Fixtures.kt

@@ -0,0 +1,10 @@
+val ONE_ONE_STONE = Stone.of(1, 1)
+val ONE_TWO_STONE = Stone.of(1, 2)
+val ONE_THREE_STONE = Stone.of(1, 3)
+val ONE_FOUR_STONE = Stone.of(1, 4)
+val ONE_FIVE_STONE = Stone.of(1, 5)
+val ONE_SIX_STONE = Stone.of(1, 6)
+val ONE_SEVEN_STONE = Stone.of(1, 7)
+val ONE_EIGHT_STONE = Stone.of(1, 8)
+val ONE_NINE_STONE = Stone.of(1, 9)
+val ONE_TEN_STONE = Stone.of(1, 10)

src/test/kotlin/StonesTest.kt

@@ -1,3 +1,4 @@
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertDoesNotThrow
 import org.junit.jupiter.api.assertThrows
@@ -6,14 +7,46 @@ class StonesTest {
  @Test
  fun `각각 다른 위치의 오목알을 가질 수 있다`() {
  assertDoesNotThrow {
- Stones(Stone.of(10, 10), Stone.of(11, 11))
+ Stones(ONE_ONE_STONE, ONE_TWO_STONE)
  }
  }
 
  @Test
  fun `중복되는 위치의 오목알을 가지면 에러가 발생한다`() {
  assertThrows<IllegalArgumentException> {
- Stones(Stone.of(10, 10), Stone.of(10, 10))
+ Stones(ONE_ONE_STONE, ONE_ONE_STONE)
  }
  }
+
+ @Test
+ fun `오목알을 놓을 수 있다`() {
+ val stones = Stones(ONE_ONE_STONE, ONE_TWO_STONE)
+ val newStones = stones.add(ONE_THREE_STONE)
+
+ assertThat(newStones).isEqualTo(Stones(ONE_ONE_STONE, ONE_TWO_STONE, ONE_THREE_STONE))
+ }
+
+ @Test
+ fun `오목알이 포함되어 있는지 판단한다`() {
+ val stones = Stones(ONE_ONE_STONE, ONE_TWO_STONE, ONE_THREE_STONE)
+ val expected = stones.hasStone(ONE_ONE_STONE)
+
+ assertThat(expected).isTrue
+ }
+
+ @Test
+ fun `오목알이 5개 이상 연이어 있으면 참을 반환한다`() {
+ val stones = Stones(ONE_ONE_STONE, ONE_TWO_STONE, ONE_THREE_STONE, ONE_FOUR_STONE, ONE_FIVE_STONE)
+ val expected = stones.checkWin(ONE_ONE_STONE)
+
+ assertThat(expected).isTrue
+ }
+
+ @Test
+ fun `오목알이 5개 미만 연이어 있으면 거짓을 반환한다`() {
+ val stones = Stones(ONE_ONE_STONE, ONE_TWO_STONE, ONE_THREE_STONE)
+ val expected = stones.checkWin(ONE_ONE_STONE)
+
+ assertThat(expected).isFalse
+ }
 }