[둘리] 1, 2단계 오목 제출합니다.

docs/README.md

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

src/main/kotlin/Application.kt

@@ -0,0 +1,5 @@
+import controller.OmokController
+
+fun main() {
+ OmokController().start()
+}

src/main/kotlin/controller/OmokController.kt

@@ -0,0 +1,12 @@
+package controller
+
+import domain.game.Omok
+import domain.rule.RenjuRule
+import view.InputView
+import view.OutputView
+
+class OmokController {
+ fun start() {
+ Omok(OutputView(), InputView(), RenjuRule()).run()
+ }
+}

src/main/kotlin/domain/board/Board.kt

@@ -0,0 +1,24 @@
+package domain.board
+
+import domain.player.Player
+import domain.player.Players
+import domain.rule.OmokRule
+import domain.stone.Stone
+import domain.stone.StoneColor
+
+class Board(private val players: Players) {
+ constructor(blackPlayer: Player, whitePlayer: Player, rule: OmokRule) : this(Players(blackPlayer, whitePlayer, rule))
+
+ fun putStone(stoneColor: StoneColor, stone: Stone): Board? {
+ if (players.canPlace(stone)) {
+ return Board(players.putStone(stoneColor, stone))
+ }
+ return null
+ }
+
+ fun getPlayers(): Players = players.copy()
+
+ fun isRunning(): Boolean = players.isRunning
+
+ fun isLose(): Boolean = players.isBlackLose
+}

src/main/kotlin/domain/game/Omok.kt

@@ -0,0 +1,39 @@
+package domain.game
+
+import domain.board.Board
+import domain.player.BlackPlayer
+import domain.player.WhitePlayer
+import domain.rule.OmokRule
+import domain.stone.Stone
+import domain.stone.StoneColor
+import listener.OmokStartEndEventListener
+import listener.OmokTurnEventListener
+
+class Omok(
+ private val startEndEventListener: OmokStartEndEventListener,
+ private val turnEventListener: OmokTurnEventListener,
+ private val rule: OmokRule
+) {
+ fun run() {
+ startEndEventListener.onStartGame()
+ var curStoneColor: StoneColor = StoneColor.BLACK
+ var curBoard = Board(BlackPlayer(), WhitePlayer(), rule)
+ do {
+ curBoard = takeTurn(curBoard, curStoneColor)
+ startEndEventListener.onEndTurn(curBoard.getPlayers())
+ curStoneColor = curStoneColor.next()
+ } while (curBoard.isRunning())
+ if (curBoard.isLose()) startEndEventListener.onEndGame(curStoneColor)
+ else startEndEventListener.onEndGame(curStoneColor.next())
+ }
+
+ private fun takeTurn(board: Board, stoneColor: StoneColor): Board {
+ val newStone = Stone.of(turnEventListener.onTakeTurn(stoneColor))
+ val newBoard = board.putStone(stoneColor, newStone)
+ if (newBoard == null) {
+ turnEventListener.onNotPlaceable()
+ return takeTurn(board, stoneColor)
+ }
+ return newBoard
+ }
+}

src/main/kotlin/domain/player/BlackPlayer.kt

@@ -0,0 +1,21 @@
+package domain.player
+
+import domain.rule.OmokRule
+import domain.state.LoseState
+import domain.state.PlayerState
+import domain.state.PlayingState
+import domain.stone.Stone
+import domain.stone.Stones
+
+class BlackPlayer(state: PlayerState = PlayingState()) : Player(state) {
+ val isLose
+ get() = state is LoseState
+
+ override fun putStone(stone: Stone, otherStones: Stones, rule: OmokRule): Player {
+ val blackStones = state.getAllStones()
+ if (rule.check(blackStones, otherStones, stone)) {
+ return BlackPlayer(LoseState(state.getAllStones()))
+ }
+ return BlackPlayer(state.add(stone, rule))
+ }
+}

src/main/kotlin/domain/player/Player.kt

@@ -0,0 +1,25 @@
+package domain.player
+
+import domain.position.Position
+import domain.rule.OmokRule
+import domain.state.LoseState
+import domain.state.PlayerState
+import domain.state.WinState
+import domain.stone.Stone
+import domain.stone.Stones
+
+abstract class Player(protected val state: PlayerState) : Cloneable {
+ fun canPlace(): Boolean = state !is WinState && state !is LoseState
+
+ fun isPlaced(stone: Stone): Boolean = state.hasStone(stone)
+
+ fun getPositions(): List<Position> = state.getPlaced()
+
+ fun getLastStone(): Stone = state.getLastStone()
+
+ fun getAllStones(): Stones = state.getAllStones()
+
+ abstract fun putStone(stone: Stone, otherStones: Stones, rule: OmokRule): Player
+
+ public override fun clone(): Player = super.clone() as Player
+}

src/main/kotlin/domain/player/Players.kt

@@ -0,0 +1,50 @@
+package domain.player
+
+import domain.rule.OmokRule
+import domain.rule.RenjuRule
+import domain.stone.Stone
+import domain.stone.StoneColor
+
+data class Players private constructor(private val players: List<Player>, private val rule: OmokRule) {
+ val isRunning: Boolean
+ get() = players.all { it.canPlace() }
+ val isBlackLose: Boolean
+ get() = (getBlackPlayer() as BlackPlayer).isLose
+
+ constructor(blackPlayer: Player, whitePlayer: Player, rule: OmokRule) : this(
+ listOf(
+ blackPlayer.clone(),
+ whitePlayer.clone()
+ ),
+ rule
+ )
+
+ fun putStone(stoneColor: StoneColor, stone: Stone): Players {
+ val whiteStones = getWhitePlayer().getAllStones()
+ val blackStones = getBlackPlayer().getAllStones()
+
+ return when (stoneColor) {
+ StoneColor.BLACK -> {
+ Players(
+ blackPlayer = getBlackPlayer().putStone(stone, whiteStones, RenjuRule()),
+ whitePlayer = getWhitePlayer(),
+ rule,
+ )
+ }
+
+ StoneColor.WHITE -> {
+ Players(
+ blackPlayer = getBlackPlayer(),
+ whitePlayer = getWhitePlayer().putStone(stone, blackStones, rule),
+ rule,
+ )
+ }
+ }
+ }
+
+ fun getBlackPlayer(): Player = players.first { it is BlackPlayer }
+
+ fun getWhitePlayer(): Player = players.first { it is WhitePlayer }
+
+ fun canPlace(stone: Stone): Boolean = players.none { it.isPlaced(stone) }
+}

src/main/kotlin/domain/player/WhitePlayer.kt

@@ -0,0 +1,12 @@
+package domain.player
+
+import domain.rule.OmokRule
+import domain.state.PlayerState
+import domain.state.PlayingState
+import domain.stone.Stone
+import domain.stone.Stones
+
+class WhitePlayer(state: PlayerState = PlayingState()) : Player(state) {
+ override fun putStone(stone: Stone, otherStones: Stones, rule: OmokRule): Player =
+ WhitePlayer(state.add(stone, rule))
+}

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

@@ -0,0 +1,16 @@
+package domain.position
+
+data class Position(val row: Int, val col: Int) {
+ init {
+ require(row in POSITION_RANGE) { ROW_OUT_OF_RANGE_ERROR_MESSAGE }
+ require(col in POSITION_RANGE) { COLUMN_OUT_OF_RANGE_ERROR_MESSAGE }
+ }
+
+ companion object {
+ private const val MIN_BOUND = 1
+ private const val MAX_BOUND = 15
+ val POSITION_RANGE = (MIN_BOUND..MAX_BOUND)
+ private const val ROW_OUT_OF_RANGE_ERROR_MESSAGE = "행의 범위는 ${MIN_BOUND}부터 ${MAX_BOUND}입니다"
+ private const val COLUMN_OUT_OF_RANGE_ERROR_MESSAGE = "열의 범위는 ${MIN_BOUND}부터 ${MAX_BOUND}입니다"
+ }
+}

src/main/kotlin/domain/rule/OmokRule.kt

@@ -0,0 +1,8 @@
+package domain.rule
+
+import domain.stone.Stone
+import domain.stone.Stones
+
+interface OmokRule {
+ fun check(blackStones: Stones, whiteStones: Stones, startStone: Stone): Boolean
+}