death flow enhancements

RobotHanzo · RobotHanzo · commit 8df90e210299 · 2026-02-18T05:20:09.000+08:00
diff --git a/src/main/kotlin/dev/robothanzo/werewolf/database/documents/Player.kt b/src/main/kotlin/dev/robothanzo/werewolf/database/documents/Player.kt
@@ -10,9 +10,7 @@ import dev.robothanzo.werewolf.game.model.RoleEventContext
 import dev.robothanzo.werewolf.game.model.RoleEventType
 import dev.robothanzo.werewolf.game.roles.actions.RoleAction
 import io.swagger.v3.oas.annotations.media.Schema
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlinx.coroutines.withTimeout
+import kotlinx.coroutines.*
 import net.dv8tion.jda.api.EmbedBuilder
 import net.dv8tion.jda.api.entities.Member
 import net.dv8tion.jda.api.entities.Role
@@ -344,7 +342,7 @@ data class Player(
                         delay(1000)
                     }
                 }
-            } catch (e: kotlinx.coroutines.TimeoutCancellationException) {
+            } catch (_: kotlinx.coroutines.TimeoutCancellationException) {
                 // Timeout logic - force expire if needed
                 WerewolfApplication.gameSessionService.withLockedSession(session.guildId) { lockedSession ->
                     val p = lockedSession.getPlayer(id) ?: return@withLockedSession
@@ -400,6 +398,66 @@ data class Player(
         }
     }
 
+    /**
+     * Orchestrates the entire death sequence, including this player and any subsequent deaths
+     * triggered by death events (e.g. Hunter shooting).
+     *
+     * @param onFinished Callback executed when ALL cascading deaths are resolved.
+     */
+    @OptIn(DelicateCoroutinesApi::class)
+    fun processCascadingDeaths(onFinished: () -> Unit) {
+        val session = this.session ?: return
+        val guildId = session.guildId
+
+        GlobalScope.launch {
+            try {
+                WerewolfApplication.gameSessionService.withLockedSession(guildId) { session ->
+                    session.stateData.deathProcessingInProgress = true
+                }
+
+                // 1. Process THIS player first
+                // On Day 1, everyone gets Last Words. On later days, usually only the first night death or similar.
+                // For simplicity, we respect the allowLastWords flag passed to runDeathEvents,
+                // but since this is the *entry point* for a death chain, we assume this player SHOULD get them
+                // or specific logic inside runDeathEvents/call sites handles it.
+                // For EXPEL/HUNTER cases on Day 1, they should get it.
+                val isDayOne = session.day <= 1
+                runDeathEvents(isDayOne)
+
+                // 2. Loop for others (Cascading Deaths)
+                while (true) {
+                    // Refresh session to get latest state
+                    val currentSession =
+                        WerewolfApplication.gameSessionService.getSession(guildId).orElse(null) ?: break
+
+                    // Find next unprocessed dead player
+                    // distinct from any specific logic, just "dead but not processed"
+                    val nextVictim = currentSession.players.values.firstOrNull {
+                        !it.alive && !currentSession.stateData.processedDeathPlayerIds.contains(it.id)
+                    } ?: break
+
+                    try {
+                        // All cascading victims on Day 1 get last words (Request: "players killed by hunter's skill on the first day")
+                        nextVictim.runDeathEvents(isDayOne)
+                    } catch (e: Exception) {
+                        e.printStackTrace()
+                        // Failsafe: mark processed so we don't loop forever
+                        WerewolfApplication.gameSessionService.withLockedSession(guildId) { s ->
+                            s.stateData.processedDeathPlayerIds.add(nextVictim.id)
+                        }
+                    }
+                }
+            } catch (e: Exception) {
+                e.printStackTrace()
+            } finally {
+                WerewolfApplication.gameSessionService.withLockedSession(guildId) { session ->
+                    session.stateData.deathProcessingInProgress = false
+                }
+                onFinished()
+            }
+        }
+    }
+
     companion object {
         val ID_FORMAT = DecimalFormat("00")
 
diff --git a/src/main/kotlin/dev/robothanzo/werewolf/game/model/GameStateData.kt b/src/main/kotlin/dev/robothanzo/werewolf/game/model/GameStateData.kt
@@ -167,7 +167,10 @@ data class GameStateData(
     var pendingNextStep: String? = null,
 
     @Schema(description = "The reason for game end, if detected")
-    var gameEndReason: String? = null
+    var gameEndReason: String? = null,
+
+    @Schema(description = "Flag indicating if asynchronous death processing is currently active")
+    var deathProcessingInProgress: Boolean = false
 ) {
     // --- Transient fields for UI state synchronization ---
     @Transient
diff --git a/src/main/kotlin/dev/robothanzo/werewolf/game/steps/DeathAnnouncementStep.kt b/src/main/kotlin/dev/robothanzo/werewolf/game/steps/DeathAnnouncementStep.kt
@@ -14,9 +14,6 @@ import dev.robothanzo.werewolf.game.roles.actions.RoleActionExecutor
 import dev.robothanzo.werewolf.service.GameSessionService
 import dev.robothanzo.werewolf.service.GameStateService
 import dev.robothanzo.werewolf.utils.CmdUtils
-import kotlinx.coroutines.DelicateCoroutinesApi
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.launch
 import org.slf4j.LoggerFactory
 import org.springframework.context.annotation.Lazy
 import org.springframework.stereotype.Component
@@ -97,82 +94,27 @@ class DeathAnnouncementStep(
             gameSessionService.broadcastSessionUpdate(lockedSession)
         }
 
-        // Launch async death processing
-        @OptIn(DelicateCoroutinesApi::class)
-        GlobalScope.launch {
-            while (true) {
-                // Fetch fresh session to check for new deaths
-                val currentSession = gameSessionService.getSession(guildId).orElse(null) ?: break
-
-                // Find players who are dead but haven't been processed yet
-                val toProcess = currentSession.players.values
-                    .filter { !it.alive && !currentSession.stateData.processedDeathPlayerIds.contains(it.id) }
-                    .sortedBy { it.id } // Consistent order
-
-                if (toProcess.isEmpty()) {
-                    // Check if there are any pending death triggers (someone still choosing their shot)
-                    val hasPendingTriggers = currentSession.stateData.submittedActions.any { instance ->
-                        val isUnprocessed =
-                            instance.status != ActionStatus.PROCESSED && instance.status != ActionStatus.SKIPPED
-                        val action = instance.actionDefinitionId?.let { roleRegistry.getAction(it) }
-                        action?.timing == ActionTiming.DEATH_TRIGGER && isUnprocessed
-                    }
-
-                    if (!hasPendingTriggers) break // No more deaths and no more pending shots
-
-                    kotlinx.coroutines.delay(1000) // Wait for user to take action
-                    continue
-                }
-
-                val player = toProcess.first()
-
-                // Only allow last words for first day
-                val allowLastWords = currentSession.day == 1
-                try {
-                    player.runDeathEvents(allowLastWords)
-
-                    // Mark as processed after everything (last words, triggers, etc) is done
-                    gameSessionService.withLockedSession(guildId) { lockedSession ->
-                        if (!lockedSession.stateData.processedDeathPlayerIds.contains(player.id)) {
-                            lockedSession.stateData.processedDeathPlayerIds.add(player.id)
-
-                            // Also ensure they are in the announced deadPlayers list for UI
-                            if (!lockedSession.stateData.deadPlayers.contains(player.id)) {
-                                val currentDead = lockedSession.stateData.deadPlayers.toMutableList()
-                                currentDead.add(player.id)
-                                lockedSession.stateData.deadPlayers = currentDead
-                            }
-                        }
-                    }
-                } catch (e: Exception) {
-                    log.error("Error running death events for player ${player.id}", e)
-                    // Still mark as processed to avoid infinite loop on error
-                    gameSessionService.withLockedSession(guildId) { it.stateData.processedDeathPlayerIds.add(player.id) }
-                }
-            }
-
-            // Once all events are done, check if we can advance
-            gameSessionService.withLockedSession(guildId) { lockedSession ->
-                checkAdvance(lockedSession, service)
-            }
+        // Delegate death processing to the first available dead player (if any)
+        // The processCascadingDeaths function will handle ALL unprocessed deaths in the session
+        val currentSession = gameSessionService.getSession(guildId).orElse(null)
+        val firstDead = currentSession?.players?.values?.sortedBy { it.id }?.firstOrNull {
+            !it.alive && !currentSession.stateData.processedDeathPlayerIds.contains(it.id)
         }
 
-        // Schedule tasks for potential advancement (one-shot fallbacks in case async hangs or something)
-        // Task 1: Minimum display time (10s as requested)
-        CmdUtils.schedule({
-            gameSessionService.withLockedSession(guildId) { currentSession ->
-                checkAdvance(currentSession, service)
+        if (firstDead != null) {
+            log.info("Starting death processing chain from player ${firstDead.id}")
+            firstDead.processCascadingDeaths {
+                log.info("All death events processed. Advancing step.")
+                service.nextStep(currentSession)
             }
-        }, 10000)
-
-        // Task 2: Maximum duration (backup timeout)
-        val duration = getDurationSeconds(session)
-        if (duration > 10) {
+        } else {
+            // No deaths to process, just wait for minimum duration then advance
+            log.info("No deaths to process in DeathAnnouncementStep. Scheduling advance.")
             CmdUtils.schedule({
-                gameSessionService.withLockedSession(guildId) { currentSession ->
-                    checkAdvance(currentSession, service)
+                gameSessionService.withLockedSession(guildId) { s ->
+                    service.nextStep(s)
                 }
-            }, duration * 1000L + 5000) // Small buffer
+            }, 10000)
         }
     }
 
@@ -211,8 +153,8 @@ class DeathAnnouncementStep(
             log.info("DeathAnnouncementStep timeout for guild ${session.guildId}. Advancing.")
             shouldAdvance = true
         } else if (now >= minTime) {
-            if (!hasActiveTriggers && !hasUnprocessedDeaths && !hasOngoingEvents) {
-                log.info("DeathAnnouncementStep early exit for guild ${session.guildId} (no active triggers/events). Advancing.")
+            if (!hasActiveTriggers && !hasUnprocessedDeaths && !hasOngoingEvents && !session.stateData.deathProcessingInProgress) {
+                log.info("DeathAnnouncementStep early exit for guild ${session.guildId} (no active triggers/events/processing). Advancing.")
                 shouldAdvance = true
             }
         }
diff --git a/src/main/kotlin/dev/robothanzo/werewolf/game/steps/NightStep.kt b/src/main/kotlin/dev/robothanzo/werewolf/game/steps/NightStep.kt
@@ -51,6 +51,7 @@ class NightStep(
 
     private val log = LoggerFactory.getLogger(NightStep::class.java)
     internal val nightScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+    private val orchestrationJobs = java.util.concurrent.ConcurrentHashMap<Long, Job>()
 
     override fun onStart(session: Session, service: GameStateService) {
         val guildId = session.guildId
@@ -100,11 +101,16 @@ class NightStep(
         }
 
         // Orchestrate the night phases
-        nightScope.launch {
+        orchestrationJobs[guildId]?.cancel()
+        orchestrationJobs[guildId] = nightScope.launch {
             try {
                 processNightPhases(guildId, service)
+            } catch (e: CancellationException) {
+                log.info("Night orchestration for guild $guildId was cancelled")
             } catch (e: Exception) {
                 log.error("Error during night orchestration for guild $guildId", e)
+            } finally {
+                orchestrationJobs.remove(guildId, coroutineContext[Job])
             }
         }
     }
@@ -175,12 +181,31 @@ class NightStep(
     }
 
     override fun onEnd(session: Session, service: GameStateService) {
+        val guildId = session.guildId
+        log.info("Ending NightStep for guild $guildId. Cleaning up state.")
+
+        // 1. Cancel orchestration coroutine
+        orchestrationJobs.remove(guildId)?.cancel()
+
+        // 2. Clear phase signals
+        phaseSignals.remove(guildId)
+
+        // 3. Cleanup UI prompts
         actionUIService.cleanupExpiredPrompts(session)
 
+        // 4. Clear transient night state
         session.stateData.phaseType = null
         session.stateData.phaseStartTime = 0
         session.stateData.phaseEndTime = 0
         session.stateData.wolfBrotherAwakenedPlayerId = null
+
+        // 5. Clear any PENDING or ACTING actions (Keep only SUBMITTED/SKIPPED/PROCESSED for resolution)
+        session.stateData.submittedActions.removeIf { !it.status.executed }
+
+        // 6. Clear wolf data
+        session.stateData.wolfStates.clear()
+        session.stateData.werewolfMessages.clear()
+
         gameSessionService.saveSession(session)
     }
 
diff --git a/src/main/kotlin/dev/robothanzo/werewolf/model/ExpelPoll.kt b/src/main/kotlin/dev/robothanzo/werewolf/model/ExpelPoll.kt
@@ -5,9 +5,6 @@ import dev.robothanzo.werewolf.audio.Audio
 import dev.robothanzo.werewolf.audio.Audio.play
 import dev.robothanzo.werewolf.database.documents.Session
 import dev.robothanzo.werewolf.game.model.DeathCause
-import kotlinx.coroutines.DelicateCoroutinesApi
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.launch
 import net.dv8tion.jda.api.EmbedBuilder
 import net.dv8tion.jda.api.entities.Message
 import net.dv8tion.jda.api.entities.channel.middleman.GuildMessageChannel
@@ -45,34 +42,14 @@ class ExpelPoll(
         message: Message?,
         session: Session
     ): Boolean {
-        // Announce
         message?.reply("投票已結束，正在放逐玩家 <@!" + winner.player.user?.idLong + ">")?.queue()
-
-        // Sync mark death
         winner.player.markDead(DeathCause.EXPEL)
-
-        // Async process death events
-        @OptIn(DelicateCoroutinesApi::class)
-        GlobalScope.launch {
-            try {
-                // Must fetch fresh player session context or ensure it is valid
-                // Since this runs after sync markDead, session state is updated.
-                // We restart a coroutine flow for interaction
-                winner.player.runDeathEvents(true)
-            } catch (e: Exception) {
-                e.printStackTrace()
-            } finally {
-                // Execute the poll finished callback (advancing step etc)
-                // We must be careful about thread safety if callback touches session
-                // finishedCallback usually calls service.nextStep which locks session.
-                finishedCallback?.invoke()
-            }
+        winner.player.processCascadingDeaths {
+            finishedCallback?.invoke()
         }
-
-        // Finally remove poll registration
         WerewolfApplication.expelService.removePoll(guildId)
 
-        return true // We handle the callback
+        return true
     }
 
     override fun onPKTie(winners: List<Candidate>, channel: GuildMessageChannel, message: Message?, session: Session) {
diff --git a/src/test/kotlin/dev/robothanzo/werewolf/game/PlayerDeathTests.kt b/src/test/kotlin/dev/robothanzo/werewolf/game/PlayerDeathTests.kt
diff --git a/src/test/kotlin/dev/robothanzo/werewolf/game/roles/WitchAntidoteTests.kt b/src/test/kotlin/dev/robothanzo/werewolf/game/roles/WitchAntidoteTests.kt
