feat: 오목 게임 진행하는 기능 구현

docs/README.md

@@ -1,7 +1,10 @@
 ## 오목
 
 ### Domain
-- [ ] 흑돌이 먼저 시작한다.
+- [ ] 한 플레이어라도 승리할 때까지 차례를 번갈아가면서 돌을 놓는다.
+ - [x] 흑, 백 플레이어를 가지고 있다
+ - [x] 흑돌이 먼저 시작한다.
+ - [ ] 게임의 진행 여부는 `PlayerState`가 결정한다.
 - [x] 오목알은 자신의 위치를 알고 있다.
  - [x] `x, y` 위치는 `1부터 15`로 제한된다.
 - [x] 중복되는 위치의 오목알을 가질 수 없다.
@@ -14,11 +17,11 @@
 - [x] 오목알을 놓은 플레이어가 게임에서 이겼는지 확인한다.
 - [x] 사용자는 특정 위치에 내 돌이 있는지 확인한다.
 - [x] 사용자는 마지막 돌의 위치를 알고 있다.
-- [ ] 게임의 진행 여부는 `PlayerState`가 결정한다.
 - [x] 오목알을 놓으면 상대방의 차례가 된다.
 
 ### Input
 - [ ] 오목알을 놓을 위치를 입력받는다.
 
 ### Output
 - [ ] 오목알의 위치를 입력받기 전에 오목판을 출력한다.
+- [ ] 마지막 돌의 위치를 출력한다.

src/main/kotlin/Board.kt

@@ -1,17 +1,22 @@
-import Position.Companion.POSITION_RANGE
 import player.Player
 import player.Players
 
 class Board(private val players: Players) {
  constructor(blackPlayer: Player, whitePlayer: Player) : this(Players(blackPlayer, whitePlayer))
 
- fun putStone(turn: Turn, stone: Stone): Player? {
+ fun putStone(stoneColor: StoneColor, stone: Stone): Board? {
  if (players.canPlace(stone)) {
- return players.putStone(turn, stone)
+ return Board(players.putStone(stoneColor, stone))
  }
  return null
  }
 
- private fun makeEmptyBoard(): List<MutableList<BoardState>> =
- List(POSITION_RANGE.max()) { MutableList(POSITION_RANGE.max()) { BoardState.EMPTY } }
+ fun getPlayers(): Players = players.copy()
+
+ fun isRunning(): Boolean = players.isRunning
+
+ fun getWinner(): Player = players.getWinner()
+
+ // private fun makeEmptyBoard(): List<MutableList<BoardState>> =
+ // List(POSITION_RANGE.max()) { MutableList(POSITION_RANGE.max()) { BoardState.EMPTY } }
 }

src/main/kotlin/Stone.kt

@@ -4,6 +4,7 @@ data class Stone private constructor(val position: Position) {
  companion object {
  private val STONES = POSITION_RANGE.map { row -> POSITION_RANGE.map { col -> Stone(Position(row, col)) } }
 
- fun of(row: Int, col: Int) = STONES[row - 1][col - 1]
+ fun of(row: Int, col: Int): Stone = STONES[row - 1][col - 1]
+ fun of(position: Position): Stone = STONES[position.row - 1][position.col - 1]
  }
 }

src/main/kotlin/Turn.kt → src/main/kotlin/StoneColor.kt

@@ -1,7 +1,7 @@
-enum class Turn {
+enum class StoneColor {
  BLACK, WHITE;
 
- fun next(): Turn = when (this) {
+ fun next(): StoneColor = when (this) {
  BLACK -> WHITE
  WHITE -> BLACK
  }

src/main/kotlin/game/Omok.kt

@@ -0,0 +1,30 @@
+package game
+
+import Board
+import Stone
+import StoneColor
+import listener.OmokEventListener
+import player.BlackPlayer
+import player.WhitePlayer
+
+class Omok(private val eventListener: OmokEventListener) {
+ private val board = Board(BlackPlayer(), WhitePlayer())
+
+ fun run() {
+ eventListener.onStartGame()
+ var currentStoneColor: StoneColor = StoneColor.BLACK
+ var currentBoard: Board = board
+ do {
+ currentBoard = takeTurn(currentBoard, currentStoneColor)
+ eventListener.onEndTurn(currentBoard.getPlayers())
+ currentStoneColor = currentStoneColor.next()
+ } while (currentBoard.isRunning())
+
+ eventListener.onEndGame(board.getWinner())
+ }
+
+ private fun takeTurn(board: Board, stoneColor: StoneColor): Board {
+ val newStone = Stone.of(eventListener.onTakeTurn(stoneColor))
+ return board.putStone(stoneColor, newStone) ?: return takeTurn(board, stoneColor)
+ }
+}

src/main/kotlin/listener/OmokEventListener.kt

@@ -0,0 +1,13 @@
+package listener
+
+import Position
+import StoneColor
+import player.Player
+import player.Players
+
+interface OmokEventListener {
+ fun onStartGame()
+ fun onTakeTurn(stoneColor: StoneColor): Position
+ fun onEndTurn(positions: Players)
+ fun onEndGame(player: Player)
+}

src/main/kotlin/player/BlackPlayer.kt

@@ -1,11 +1,9 @@
 package player
 
-import BoardState
 import Stone
 import state.PlayerState
 import state.PlayingState
 
 class BlackPlayer(state: PlayerState = PlayingState()) : Player(state) {
- override val boardState: BoardState = BoardState.BLACK
  override fun putStone(stone: Stone): Player = BlackPlayer(state.add(stone))
 }

src/main/kotlin/player/Player.kt

@@ -1,18 +1,22 @@
 package player
 
-import BoardState
 import Position
 import Stone
 import state.PlayerState
+import state.WinState
 
-abstract class Player(protected val state: PlayerState) {
- abstract val boardState: BoardState
+abstract class Player(protected val state: PlayerState) : Cloneable {
+ val isWin: Boolean = state is WinState
 
  abstract fun putStone(stone: Stone): Player
 
+ fun canPlace(): Boolean = state !is WinState
+
  fun isPlaced(stone: Stone): Boolean = state.hasStone(stone)
 
- fun getPlaced(): List<Position> = state.getPlaced()
+ fun getPositions(): List<Position> = state.getPlaced()
 
  fun getLastStone(): Stone = state.getLastStone()
+
+ public override fun clone(): Player = super.clone() as Player
 }

src/main/kotlin/player/Players.kt

@@ -1,12 +1,26 @@
 package player
 
 import Stone
-import Turn
+import StoneColor
 
-class Players private constructor(private val players: Map<Turn, Player>) {
- constructor(black: Player, white: Player) : this(mapOf(Turn.BLACK to black, Turn.WHITE to white))
+data class Players private constructor(private val players: List<Player>) {
+ val isRunning: Boolean
+ get() = players.all { it.canPlace() }
 
- fun putStone(turn: Turn, stone: Stone): Player? = players[turn]?.putStone(stone)
+ constructor(blackPlayer: Player, whitePlayer: Player) : this(listOf(blackPlayer.clone(), whitePlayer.clone()))
 
- fun canPlace(stone: Stone): Boolean = players.values.none { it.isPlaced(stone) }
+ fun putStone(stoneColor: StoneColor, stone: Stone): Players {
+ if (stoneColor == StoneColor.BLACK) {
+ return Players(blackPlayer = getBlackPlayer().putStone(stone), whitePlayer = getWhitePlayer())
+ }
+ return Players(blackPlayer = getBlackPlayer(), whitePlayer = getWhitePlayer().putStone(stone))
+ }
+
+ fun getBlackPlayer(): Player = players.first { it is BlackPlayer }
+
+ fun getWhitePlayer(): Player = players.first { it is WhitePlayer }
+
+ fun getWinner(): Player = players.first { it.isWin }
+
+ fun canPlace(stone: Stone): Boolean = players.none { it.isPlaced(stone) }
 }

src/main/kotlin/player/WhitePlayer.kt

@@ -1,11 +1,9 @@
 package player
 
-import BoardState
 import Stone
 import state.PlayerState
 import state.PlayingState
 
 class WhitePlayer(state: PlayerState = PlayingState()) : Player(state) {
- override val boardState: BoardState = BoardState.WHITE
  override fun putStone(stone: Stone): Player = WhitePlayer(state.add(stone))
 }

src/main/kotlin/state/PlayerState.kt

@@ -10,5 +10,6 @@ abstract class PlayerState(protected val stones: Stones = Stones()) {
  fun hasStone(stone: Stone): Boolean = stones.hasStone(stone)
 
  fun getPlaced(): List<Position> = stones.getPositions()
+
  fun getLastStone(): Stone = stones.lastStone
 }

src/test/kotlin/BoardTest.kt

@@ -11,14 +11,14 @@ class BoardTest {
  val blackPlayer: Player = BlackPlayer(PlayingState(Stones(ONE_ONE_STONE)))
  val whitePlayer: Player = WhitePlayer(PlayingState(Stones(ONE_TWO_STONE)))
  val board = Board(blackPlayer, whitePlayer)
- assertThat(board.putStone(Turn.BLACK, ONE_THREE_STONE)).isInstanceOf(Player::class.java)
+ assertThat(board.putStone(StoneColor.BLACK, ONE_THREE_STONE)).isInstanceOf(Player::class.java)
  }
 
  @Test
  fun `특정 위치에 돌을 놓지 못하면 null을 반환한다`() {
  val blackPlayer: Player = BlackPlayer(PlayingState(Stones(ONE_ONE_STONE)))
  val whitePlayer: Player = WhitePlayer(PlayingState(Stones(ONE_TWO_STONE)))
  val board = Board(blackPlayer, whitePlayer)
- assertThat(board.putStone(Turn.BLACK, ONE_TWO_STONE)).isNull()
+ assertThat(board.putStone(StoneColor.BLACK, ONE_TWO_STONE)).isNull()
  }
 }

src/test/kotlin/OmokTest.kt

@@ -0,0 +1,9 @@
+import game.Omok
+import org.junit.jupiter.api.Test
+
+class OmokTest {
+ @Test
+ fun `한 플레이어라도 승리할 때까지 차례를 번갈아가면서 돌을 놓는다`() {
+ val omok = Omok()
+ }
+}

src/test/kotlin/TurnTest.kt → src/test/kotlin/StoneColorTest.kt

@@ -2,11 +2,11 @@ import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.CsvSource
 
-class TurnTest {
+class StoneColorTest {
  @CsvSource("WHITE, BLACK", "BLACK, WHITE")
  @ParameterizedTest
- fun `상대방 차례를 반환한다`(myTurn: Turn, expected: Turn) {
- val actual = myTurn.next()
+ fun `상대방 차례를 반환한다`(myStoneColor: StoneColor, expected: StoneColor) {
+ val actual = myStoneColor.next()
  assertThat(actual).isEqualTo(expected)
  }
 }