refactor: 퀴즈게임상태로직개선

src/main/kotlin/yjh/cstar/chat/presentation/request/AnswerMessageRequest.kt

@@ -8,10 +8,12 @@ data class AnswerMessageRequest(
     val nickname: String,
 )
 
-fun AnswerMessageRequest.toPlayerAnswer(roomId: Long, PlayerId: Long) = PlayerAnswer(
-    answer,
-    quizId,
-    roomId,
-    roomId,
-    nickname
-)
+fun AnswerMessageRequest.toPlayerAnswer(roomId: Long, playerId: Long): PlayerAnswer {
+    return PlayerAnswer(
+        answer = answer,
+        quizId = quizId,
+        roomId = roomId,
+        playerId = playerId,
+        nickname = nickname
+    )
+}

src/main/kotlin/yjh/cstar/game/application/GameService.kt

@@ -4,8 +4,8 @@ import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
 import yjh.cstar.game.domain.GameStartCommand
 import yjh.cstar.member.application.MemberService
-import yjh.cstar.play.application.GamePlayService
 import yjh.cstar.play.application.request.QuizDto
+import yjh.cstar.play.presentation.GamePlayEngine
 import yjh.cstar.quiz.application.QuizService
 import yjh.cstar.room.application.RoomService
 
@@ -15,7 +15,7 @@ class GameService(
     val memberService: MemberService,
     val roomService: RoomService,
     val quizService: QuizService,
-    val gamePlayService: GamePlayService,
+    val gamePlayEngine: GamePlayEngine,
 ) {
     @Transactional
     fun start(command: GameStartCommand) {
@@ -25,7 +25,7 @@ class GameService(
 
         val randomQuizData: List<QuizDto> = getRandomQuizData(command)
 
-        gamePlayService.start(playerInfo, randomQuizData, command.roomId, command.quizCategoryId)
+        gamePlayEngine.start(playerInfo, randomQuizData, command.roomId, command.quizCategoryId)
     }
 
     private fun getRandomQuizData(command: GameStartCommand) =

src/main/kotlin/yjh/cstar/play/application/GamePlayService.kt

@@ -1,21 +1,55 @@
 package yjh.cstar.play.application
 
-import org.springframework.scheduling.annotation.Async
 import org.springframework.stereotype.Service
+import yjh.cstar.common.BaseException
+import yjh.cstar.game.application.GameResultService
+import yjh.cstar.play.application.port.AnswerProvider
+import yjh.cstar.play.application.port.GameNotifier
+import yjh.cstar.play.application.port.RankingHandler
 import yjh.cstar.play.application.request.QuizDto
+import yjh.cstar.play.application.request.toModel
+import yjh.cstar.play.domain.GameConfig
+import yjh.cstar.play.domain.QuizGame
+import yjh.cstar.play.domain.game.GameInfo
+import yjh.cstar.room.application.RoomService
 import yjh.cstar.util.Logger
 
 @Service
 class GamePlayService(
-    private val quizGameService: QuizGameService,
+    private val answerProvider: AnswerProvider,
+    private val gameNotifier: GameNotifier,
+    private val rankingHandler: RankingHandler,
+    private val gameResultService: GameResultService,
+    private val roomService: RoomService,
 ) {
 
-    @Async("GamePlayThreadPool")
-    fun start(players: Map<Long, String>, quizzes: List<QuizDto>, roomId: Long, categoryId: Long) {
-        Logger.info("[INFO] 게임 엔진 스레드 시작 - roomId : $roomId")
+    fun play(players: Map<Long, String>, randomQuizzes: List<QuizDto>, roomId: Long, categoryId: Long) {
+        try {
+            val gameInfo = GameInfo.of(
+                players = players,
+                quizzes = randomQuizzes.map { it.toModel() },
+                roomId = roomId,
+                categoryId = categoryId
+            )
 
-        quizGameService.play(players, quizzes, roomId, categoryId)
+            val gameConfig = GameConfig(
+                answerProvider,
+                gameNotifier,
+                rankingHandler,
+                gameResultService,
+                roomService
+            )
+            val quizGame = QuizGame.of(gameInfo, gameConfig)
 
-        Logger.info("[INFO] 게임 엔진 스레드 종료 - roomId : $roomId")
+            quizGame.initialize()
+            quizGame.run()
+            quizGame.finishGame()
+        } catch (e: BaseException) {
+            Logger.error(e.toString())
+            roomService.endGameAndResetRoom(roomId)
+        } catch (e: Exception) {
+            Logger.error(e.toString())
+            roomService.endGameAndResetRoom(roomId)
+        }
     }
 }

src/main/kotlin/yjh/cstar/play/application/port/AnswerProvider.kt

@@ -4,7 +4,7 @@ import yjh.cstar.play.domain.player.PlayerAnswer
 
 interface AnswerProvider {
 
-    fun receivePlayerAnswer(roomId: Long, quizId: Long): PlayerAnswer?
+    fun receivePlayerAnswer(roomId: Long, quizId: Long, awaitSecond: Long): PlayerAnswer?
 
     fun initializePlayerAnswerToReceive(roomId: Long, quizId: Long)
 }

src/main/kotlin/yjh/cstar/play/application/port/RankingHandler.kt

@@ -7,9 +7,9 @@ interface RankingHandler {
 
     fun initRankingBoard(roomId: Long, players: Players)
 
-    fun assignScoreToPlayer(roomId: Long, playerId: Long)
+    fun assignScoreToRoundWinner(roomId: Long, roundWinner: Long)
 
-    fun getWinner(roomId: Long): Long
+    fun getWinnerId(roomId: Long): Long
 
     fun getRanking(roomId: Long): Ranking
 }

src/main/kotlin/yjh/cstar/play/domain/GameConfig.kt

@@ -0,0 +1,15 @@
+package yjh.cstar.play.domain
+
+import yjh.cstar.game.application.GameResultService
+import yjh.cstar.play.application.port.AnswerProvider
+import yjh.cstar.play.application.port.GameNotifier
+import yjh.cstar.play.application.port.RankingHandler
+import yjh.cstar.room.application.RoomService
+
+data class GameConfig(
+    val answerProvider: AnswerProvider,
+    val gameNotifier: GameNotifier,
+    val rankingHandler: RankingHandler,
+    val gameResultService: GameResultService,
+    val roomService: RoomService,
+)

src/main/kotlin/yjh/cstar/play/domain/QuizGame.kt

@@ -11,10 +11,14 @@ import yjh.cstar.play.domain.game.GameInfo
 import yjh.cstar.play.domain.game.GameInitializable
 import yjh.cstar.play.domain.game.GameRunnable
 import yjh.cstar.play.domain.player.Players
-import yjh.cstar.play.domain.quiz.Quizzes
+import yjh.cstar.play.domain.quiz.Quiz
+import yjh.cstar.play.domain.quiz.RoomQuizSet
 import yjh.cstar.play.domain.ranking.Ranking
 import yjh.cstar.room.application.RoomService
 import yjh.cstar.util.Logger
+import yjh.cstar.util.TimeUtil.Companion.getCurrentLocalDateTime
+import yjh.cstar.util.TimeUtil.Companion.getCurrentTime
+import yjh.cstar.util.TimeUtil.Companion.getDuration
 import java.time.LocalDateTime
 
 class QuizGame(
@@ -26,117 +30,130 @@ class QuizGame(
     private val roomService: RoomService,
 ) : GameInitializable, GameRunnable, GameFinalizable {
 
-    private val players = gameInfo.players
-    private val quizzes = gameInfo.quizzes
-    private val roomId = gameInfo.roomId
-    private val categoryId = gameInfo.categoryId
-    private val destination = "/topic/rooms/$roomId"
+    private val players: Players = gameInfo.players
+    private val roomQuizSet: RoomQuizSet = gameInfo.roomQuizSet
+    private val roomId: Long = gameInfo.roomId
+    private val categoryId: Long = gameInfo.categoryId
+    private val destination: String = "/topic/rooms/$roomId"
 
     companion object {
-        const val TIME_LIMIT_MILLIS = 10000 // TODO("사용자의 입력을 받도록 개선")
+        const val TIME_LIMIT_DURATION = 10000
+
+        fun of(gameInfo: GameInfo, gameConfig: GameConfig): QuizGame {
+            return QuizGame(
+                gameInfo = gameInfo,
+                answerProvider = gameConfig.answerProvider,
+                gameNotifier = gameConfig.gameNotifier,
+                rankingHandler = gameConfig.rankingHandler,
+                gameResultService = gameConfig.gameResultService,
+                roomService = gameConfig.roomService
+            )
+        }
     }
 
     override fun initialize() {
         rankingHandler.initRankingBoard(roomId, players)
     }
 
     override fun run() {
-        val gameStartedAt = getCurrentAt()
+        val gameStartedAt = getCurrentLocalDateTime()
+
         gameNotifier.notifyGameStartComments(destination, gameInfo.roomId)
 
         try {
-            for ((index, quiz) in quizzes.getQuizList().withIndex()) {
-                val quizNo = index + 1
-                val quizId = quiz.id
+            runGameWhile({ roomQuizSet.isRunning() }) {
+                val quizInfo = roomQuizSet.getNextQuizInfo()
+                val (quizNo, quizId, quiz) = quizInfo
 
-                answerProvider.initializePlayerAnswerToReceive(roomId, quizId)
+                submitQuizToPlayers(quizId, quizNo, quiz)
+            }
 
-                gameNotifier.notifyQuizQuestion(destination, quizNo, quiz)
+            val winnerId: Long = findWinnerId()
+            notifyWinnerInfo(winnerId)
 
-                val roundStartTime = getCurrentTime()
-                // TODO("while true 를 사용하지 않도록 수정할 것")
-                while (true) {
-                    Logger.info("[INFO] 정답 대기중...")
+            val ranking = rankingHandler.getRanking(roomId)
+            saveGameResult(ranking, winnerId, gameStartedAt)
+        } catch (e: BaseException) {
+            Logger.error(e)
+        } catch (e: Exception) {
+            Logger.error(e.stackTraceToString())
+            Logger.error("[ERROR] 프로그램 내부에 문제가 생겼습니다.")
+        }
+    }
 
-                    gameNotifier.notifyCountdown(destination)
+    override fun finishGame() {
+        roomService.endGameAndResetRoom(roomId)
+    }
+
+    private fun submitQuizToPlayers(quizId: Long, quizNo: Int, quiz: Quiz) {
+        answerProvider.initializePlayerAnswerToReceive(roomId, quizId)
 
-                    if (isTimeOut(roundStartTime)) {
-                        gameNotifier.notifyTimeOut(destination)
-                        break
-                    }
+        gameNotifier.notifyQuizQuestion(destination, quizNo, quiz)
 
-                    /**
-                     * 1초 동안 플레이어 응답을 대기합니다.(Blocking)
-                     */
-                    val playerAnswer = answerProvider.receivePlayerAnswer(roomId, quizId)
-                        ?: continue
+        val roundStartTime = getCurrentTime()
 
-                    if (playerAnswer.isCorrect(quiz)) {
-                        val roundWinnerId = playerAnswer.playerId
+        while (true) {
+            Logger.info("[INFO] 정답 대기중...")
 
-                        rankingHandler.assignScoreToPlayer(roomId, roundWinnerId)
-                        notifyRanking()
+            gameNotifier.notifyCountdown(destination)
 
-                        notifyRoundResult(roundWinnerId)
-                        break
-                    }
-                }
+            if (isTimeOut(roundStartTime)) {
+                gameNotifier.notifyTimeOut(destination)
+                break
             }
 
-            findAndSendWinner(players)
+            val playerAnswer = answerProvider.receivePlayerAnswer(
+                roomId = roomId,
+                quizId = quizId,
+                awaitSecond = 1L
+            ) ?: continue
 
-            recordGameResult(gameStartedAt)
-        } catch (e: BaseException) {
-            Logger.error(e)
-        } catch (e: Exception) {
-            Logger.error("[ERROR] 프로그램 내부에 문제가 생겼습니다.")
+            if (playerAnswer.isCorrect(quiz)) {
+                val roundWinnerId = playerAnswer.playerId
+
+                rankingHandler.assignScoreToRoundWinner(roomId, roundWinnerId)
+                notifyRanking()
+
+                notifyRoundResult(roundWinnerId)
+                break
+            }
         }
     }
 
-    override fun finishGame() {
-        roomService.endGameAndResetRoom(roomId)
+    private fun runGameWhile(isRunning: () -> Boolean, action: () -> Unit) {
+        while (isRunning()) {
+            action()
+        }
     }
 
-    private fun recordGameResult(gameStartedAt: LocalDateTime) {
-        val ranking = rankingHandler.getRanking(roomId)
-        saveGameResult(ranking, quizzes, gameStartedAt)
+    private fun notifyWinnerInfo(winnerId: Long) {
+        val winnerNickname = players.getNickname(winnerId)
+        gameNotifier.notifyGameResult(destination, winnerId, winnerNickname)
     }
 
-    private fun saveGameResult(ranking: Ranking, quizzes: Quizzes, gameStartedAt: LocalDateTime) {
-        val winnerId = findWinner()
+    private fun saveGameResult(ranking: Ranking, winnerId: Long, gameStartedAt: LocalDateTime) {
         val gameResultCreateCommand = GameResultCreateCommand(
             ranking.getRanking(),
             roomId,
             winnerId,
-            quizzes.getSize(),
+            roomQuizSet.getSize(),
             categoryId,
             gameStartedAt
         )
         gameResultService.create(gameResultCreateCommand)
     }
 
-    private fun isTimeOut(startTime: Long) = getDuration(startTime) >= TIME_LIMIT_MILLIS
-
-    private fun findAndSendWinner(players: Players) {
-        val winnerId = findWinner()
-        val winnerNickname = players.getNickname(winnerId)
-        gameNotifier.notifyGameResult(destination, winnerId, winnerNickname)
-    }
-
-    private fun notifyRoundResult(roundWinnerId: Long) {
+    private fun notifyRoundResult(roundWinnerId: Long) =
         gameNotifier.notifyRoundResult(destination, roundWinnerId, players.getNickname(roundWinnerId))
-    }
 
     private fun notifyRanking() {
         val ranking = rankingHandler.getRanking(roomId)
         gameNotifier.notifyRanking(destination, players, ranking)
     }
 
-    private fun findWinner() = rankingHandler.getWinner(roomId)
-
-    private fun getCurrentTime() = System.currentTimeMillis()
-
-    private fun getCurrentAt() = LocalDateTime.now()
+    private fun findWinnerId(): Long =
+        rankingHandler.getWinnerId(roomId)
 
-    private fun getDuration(pastTime: Long) = getCurrentTime() - pastTime
+    private fun isTimeOut(startTime: Long): Boolean =
+        getDuration(startTime) >= TIME_LIMIT_DURATION
 }