[전남대 Android_장현지] 미션 제출합니다.

README.md

@@ -1 +1,12 @@
-# android-omok-precourse
+# android-omok-precourse
+
+### 기능 목록
+- 수는 검은돌, 흰돌을 번갈아가며 놓을 수 있다.
+- 가로, 세로, 대각선에서 같은 색상의 돌이 5개 이상 놓이면, 해당 색상의 돌이 승리한다.
+- 승자가 결정되면, 게임이 종료된다.
+
+### 요구사항
+- build.gradle.kts 파일을 변경하지 않는다.
+- 테스트 코드를 사용하여 기능 목록이 정상적으로 작동하는지 테스트한다.
+- 함수 라인이 15라인을 넘어가지 않도록 구현한다.
+- 예외 처리를 통해 프로그램의 강제 종료를 방지한다.

app/src/main/AndroidManifest.xml

@@ -13,7 +13,7 @@
         android:theme="@style/Theme.Omok"
         tools:targetApi="31">
         <activity
-            android:name=".MainActivity"
+            android:name=".view.MainActivity"
             android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />

app/src/main/java/nextstep/omok/OmokContract.kt

@@ -0,0 +1,37 @@
+package nextstep.omok
+
+import nextstep.omok.model.GameState
+import nextstep.omok.model.IntersectionState
+import nextstep.omok.model.PlayerType
+
+interface OmokContract {
+    interface OmokView {
+        fun showTurn(currentTurn: Int, currentPlayerType: PlayerType)
+        fun placeStone(rowIndex: Int, colIndex: Int, playerType: PlayerType)
+        fun endGame(winner: PlayerType)
+    }
+
+    interface OmokModel {
+        /* currentPlayer 관련 함수 */
+        fun togglePlayer()
+        fun getPlayer(): PlayerType
+
+        /* omokBoard 관련 함수 */
+        fun updateBoard(rowIndex: Int, colIndex: Int, stone: IntersectionState)
+        fun getBoardState(rowIndex: Int, colIndex: Int): IntersectionState
+
+        /* turn 관련 함수 */
+        fun addTurnCount()
+        fun getTurn(): Int
+
+        /* currentGameState 관련 함수 */
+        fun checkWinnerExist()
+        fun getGameState(): GameState
+    }
+
+    interface OmokPresenter {
+        fun onIntersectionClick(rowIndex: Int, colIndex: Int)
+        // Player에 맞는 돌을 놓는다.
+        // turn이 9이상일 때부터, 게임이 종료되었는지 판단한다.
+    }
+}

app/src/main/java/nextstep/omok/model/CurrentPlayer.kt

@@ -0,0 +1,16 @@
+package nextstep.omok.model
+
+object CurrentPlayer {
+    private var currentPlayer: PlayerType = PlayerType.WithBlackStone
+
+    fun togglePlayer() {
+        currentPlayer = when (currentPlayer) {
+            PlayerType.WithBlackStone -> PlayerType.WithWhiteStone
+            PlayerType.WithWhiteStone -> PlayerType.WithBlackStone
+        }
+    }
+
+    fun getPlayer(): PlayerType {
+        return currentPlayer
+    }
+}

app/src/main/java/nextstep/omok/model/GameState.kt

@@ -0,0 +1,6 @@
+package nextstep.omok.model
+
+sealed class GameState {
+    data object OnGoing : GameState()
+    data object End : GameState()
+}

app/src/main/java/nextstep/omok/model/IntersectionState.kt

@@ -0,0 +1,7 @@
+package nextstep.omok.model
+
+sealed class IntersectionState {
+    data object Empty: IntersectionState()
+    data object OnWhiteStone: IntersectionState()
+    data object OnBlackStone: IntersectionState()
+}

app/src/main/java/nextstep/omok/model/OmokBoard.kt

@@ -0,0 +1,27 @@
+package nextstep.omok.model
+
+object OmokBoard {
+    private val omokBoard: MutableList<MutableList<IntersectionState>> = mutableListOf()
+
+    init {
+        for(i in 0..14) {
+            val boardRow = mutableListOf<IntersectionState>()
+            for(j in 0..14) {
+                boardRow.add(IntersectionState.Empty)
+            }
+            omokBoard.add(boardRow)
+        }
+    }
+
+    fun updateBoard(rowIndex: Int, colIndex: Int, stone: IntersectionState) {
+        omokBoard[rowIndex][colIndex] = stone
+    }
+
+    fun getBoard(): List<List<IntersectionState>> {
+        return omokBoard
+    }
+
+    fun getBoardIntersection(row: Int, col: Int): IntersectionState {
+        return omokBoard[row][col]
+    }
+}

app/src/main/java/nextstep/omok/model/OmokModel.kt

@@ -0,0 +1,57 @@
+package nextstep.omok.model
+
+import nextstep.omok.OmokContract
+import nextstep.omok.util.GameStateValidator
+
+class OmokModel : OmokContract.OmokModel {
+    private var currentPlayer: CurrentPlayer = CurrentPlayer
+    private val omokBoard = OmokBoard
+    private var turn: Int = 1
+    private var currentGameState: GameState = GameState.OnGoing
+    private val gameStateValidator: GameStateValidator by lazy { GameStateValidator }
+
+    /* currentPlayer 관련 함수 */
+    override fun togglePlayer() {
+        currentPlayer.togglePlayer()
+    }
+
+    override fun getPlayer(): PlayerType {
+        return currentPlayer.getPlayer()
+    }
+
+
+    /* omokBoard 관련 함수 */
+    override fun updateBoard(rowIndex: Int, colIndex: Int, stone: IntersectionState) {
+        omokBoard.updateBoard(rowIndex, colIndex, stone)
+    }
+
+    override fun getBoardState(rowIndex: Int, colIndex: Int): IntersectionState {
+        return omokBoard.getBoardIntersection(rowIndex, colIndex)
+    }
+
+
+    /* turn 관련 함수 */
+    override fun addTurnCount() {
+        turn++
+    }
+
+    override fun getTurn(): Int {
+        return turn
+    }
+
+
+    /* currentGameState 관련 함수 */
+    override fun checkWinnerExist() {
+        if (gameStateValidator.isWinnerExist(omokBoard.getBoard())) {
+            endGame()
+        }
+    }
+
+    override fun getGameState(): GameState {
+        return currentGameState
+    }
+
+    private fun endGame() {
+        currentGameState = GameState.End
+    }
+}

app/src/main/java/nextstep/omok/model/PlayerType.kt

@@ -0,0 +1,17 @@
+package nextstep.omok.model
+
+import nextstep.omok.R
+
+sealed class PlayerType {
+    abstract val stone: IntersectionState
+    abstract val resourceId: Int
+    data object WithWhiteStone: PlayerType() {
+        override val stone = IntersectionState.OnWhiteStone
+        override val resourceId: Int = R.drawable.white_stone
+    }
+
+    data object WithBlackStone: PlayerType() {
+        override val stone = IntersectionState.OnBlackStone
+        override val resourceId: Int = R.drawable.black_stone
+    }
+}

app/src/main/java/nextstep/omok/presenter/OmokPresenter.kt

@@ -0,0 +1,52 @@
+package nextstep.omok.presenter
+
+import nextstep.omok.OmokContract
+import nextstep.omok.model.GameState
+import nextstep.omok.model.IntersectionState
+
+class OmokPresenter(
+    private var activity: OmokContract.OmokView,
+    private var model: OmokContract.OmokModel
+) : OmokContract.OmokPresenter {
+    override fun onIntersectionClick(rowIndex: Int, colIndex: Int) {
+        if (model.getBoardState(rowIndex, colIndex) == IntersectionState.Empty) {
+            updateBoard(rowIndex, colIndex)
+            checkWinnerExist()
+        }
+    }
+
+    private fun updateBoard(rowIndex: Int, colIndex: Int) {
+        model.updateBoard(rowIndex, colIndex, model.getPlayer().stone)
+        activity.placeStone(rowIndex, colIndex, model.getPlayer())
+    }
+
+    private fun checkWinnerExist() {
+        if (model.getTurn() > 8) {
+            model.checkWinnerExist()
+            checkCurrentGameState()
+        } else {
+            onGameOnGoing()
+        }
+    }
+
+    private fun checkCurrentGameState() {
+        when (model.getGameState()) {
+            GameState.OnGoing -> {
+                onGameOnGoing()
+            }
+            GameState.End -> {
+                onGameEnd()
+            }
+        }
+    }
+
+    private fun onGameOnGoing() {
+        model.togglePlayer()
+        model.addTurnCount()
+        activity.showTurn(model.getTurn(), model.getPlayer())
+    }
+
+    private fun onGameEnd() {
+        activity.endGame(model.getPlayer())
+    }
+}

app/src/main/java/nextstep/omok/util/GameStateValidator.kt

@@ -0,0 +1,62 @@
+package nextstep.omok.util
+
+import nextstep.omok.model.IntersectionState
+
+private const val WIN_CONDITION = 5
+
+object GameStateValidator {
+    private var board: List<List<IntersectionState>> = listOf()
+    private val directions = arrayOf(Pair(0, 1), Pair(1, 0), Pair(1, 1), Pair(1, -1),)
+
+    fun isWinnerExist(board: List<List<IntersectionState>>): Boolean {
+        this.board = board
+        for (row in board.indices) {
+            for (col in board[row].indices) {
+                if (checkBoard(col, row))
+                    return true
+            }
+        }
+        return false
+    }
+
+    private fun checkBoard(col: Int, row: Int): Boolean {
+        val currentIntersection = board[row][col]
+        if (currentIntersection == IntersectionState.Empty)
+            return false
+
+        val isConditionSatisfied = checkAllDirections(col, row, currentIntersection)
+        if (!isConditionSatisfied)
+            return false
+
+        return when (currentIntersection) {
+            IntersectionState.OnBlackStone -> true
+            IntersectionState.OnWhiteStone -> true
+            IntersectionState.Empty -> false
+        }
+    }
+
+    private fun checkAllDirections(
+        col: Int, row: Int, currentIntersection: IntersectionState
+    ): Boolean {
+        for (direction in directions) {
+            val (dRow, dCol) = direction
+            if (checkSingleDirection(col, row, dCol, dRow, currentIntersection)) {
+                return true
+            }
+        }
+        return false
+    }
+
+    private fun checkSingleDirection(
+        col: Int, row: Int, dCol: Int, dRow: Int, currentIntersection: IntersectionState
+    ): Boolean {
+        for (i in 0 until WIN_CONDITION) {
+            val nx = col + i * dCol
+            val ny = row + i * dRow
+            if (nx !in board[0].indices || ny !in board.indices || board[ny][nx] != currentIntersection) {
+                return false
+            }
+        }
+        return true
+    }
+}

app/src/main/java/nextstep/omok/util/PlayerTextAdapter.kt

@@ -0,0 +1,13 @@
+package nextstep.omok.util
+
+import nextstep.omok.model.PlayerType
+
+const val PLAYER_WITH_BLACK_STONE = "흑돌"
+const val PLAYER_WITH_WHITE_STONE = "백돌"
+
+fun adaptPlayerText(currentPlayerType: PlayerType): String {
+    return when (currentPlayerType) {
+        PlayerType.WithBlackStone -> PLAYER_WITH_BLACK_STONE
+        PlayerType.WithWhiteStone -> PLAYER_WITH_WHITE_STONE
+    }
+}