fixed premature day ending

Author: RobotHanzo

src/main/kotlin/dev/robothanzo/werewolf/game/steps/NightStep.kt

@@ -14,7 +14,6 @@ import dev.robothanzo.werewolf.service.ActionUIService
 import dev.robothanzo.werewolf.service.GameSessionService
 import dev.robothanzo.werewolf.service.GameStateService
 import dev.robothanzo.werewolf.service.SpeechService
-import dev.robothanzo.werewolf.utils.CmdUtils
 import kotlinx.coroutines.*
 import org.slf4j.LoggerFactory
 import org.springframework.context.annotation.Lazy
@@ -150,33 +149,27 @@ class NightStep(
 
     // --- Wait Helper ---
     internal suspend fun waitForCondition(guildId: Long, durationSeconds: Int, condition: () -> Boolean): Boolean {
-        val signal = CompletableDeferred<Unit>()
-        phaseSignals[guildId] = signal
-
-        val timeoutTask = CmdUtils.schedule({
-            signal.complete(Unit)
-        }, durationSeconds * 1000L)
-
-        // Check condition loop
-        val checkJob = nightScope.launch {
-            while (isActive) {
-                if (condition()) {
-                    signal.complete(Unit)
-                    break
-                }
-                delay(1000)
-            }
-        }
+        val timeoutAt = System.currentTimeMillis() + durationSeconds * 1000L
+
+        while (System.currentTimeMillis() < timeoutAt) {
+            if (condition()) return true
 
-        try {
-            withTimeout((durationSeconds + 5) * 1000L) { // Safety timeout
-                signal.await()
+            val signal = CompletableDeferred<Unit>()
+            phaseSignals[guildId] = signal
+
+            val remainingMs = timeoutAt - System.currentTimeMillis()
+            if (remainingMs <= 0) break
+
+            try {
+                // Wait for either onEvent (signal) or 1 second poll via timeout
+                withTimeout(minOf(remainingMs, 1000L)) {
+                    signal.await()
+                }
+            } catch (_: Exception) {
+                // Ignore timeout (which acts as a poll) or other exceptions, loop and re-check condition
+            } finally {
+                phaseSignals.remove(guildId)
             }
-        } catch (_: Exception) {
-        } finally {
-            timeoutTask.cancel()
-            checkJob.cancel()
-            phaseSignals.remove(guildId)
         }
 
         return condition()

src/test/kotlin/dev/robothanzo/werewolf/game/roles/WitchAntidoteTests.kt

@@ -0,0 +1,108 @@
+package dev.robothanzo.werewolf.game.roles
+
+import dev.robothanzo.werewolf.database.documents.Player
+import dev.robothanzo.werewolf.database.documents.Session
+import dev.robothanzo.werewolf.game.model.*
+import dev.robothanzo.werewolf.game.roles.actions.*
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+
+class WitchAntidoteTests {
+    private lateinit var session: Session
+    private lateinit var roleRegistry: RoleRegistry
+    private lateinit var executor: RoleActionExecutor
+
+    @BeforeEach
+    fun setup() {
+        session = Session()
+        session.id = "test-session"
+        session.day = 1
+
+        // Mock Roles
+        val witchRole = object : BaseRole("女巫", Camp.GOD) {
+            override fun getActions() = listOf(WitchAntidoteAction(), WitchPoisonAction())
+        }
+        val werewolfRole = object : BaseRole("狼人", Camp.WEREWOLF) {}
+        val villagerRole = object : BaseRole("平民", Camp.VILLAGER) {}
+        val ghostRiderRole = object : BaseRole("惡靈騎士", Camp.WEREWOLF) {}
+
+        roleRegistry = RoleRegistry(
+            listOf(witchRole, werewolfRole, villagerRole, ghostRiderRole),
+            listOf(
+                WerewolfKillAction(),
+                WitchAntidoteAction(),
+                WitchPoisonAction(),
+                GuardProtectAction(),
+                DeathResolutionAction()
+            )
+        )
+        executor = RoleActionExecutor(roleRegistry)
+
+        // Setup Players
+        session.players["1"] = Player(id = 1, roles = mutableListOf("狼人"))
+        session.players["2"] = Player(id = 2, roles = mutableListOf("女巫"))
+        session.players["3"] = Player(id = 3, roles = mutableListOf("平民"))
+        session.players["4"] = Player(id = 4, roles = mutableListOf("惡靈騎士"))
+
+        session.players.values.forEach { it.session = session }
+    }
+
+    @Test
+    fun testWitchAntidoteSavesVillager() {
+        val wolfKill = RoleActionInstance(
+            actor = 1,
+            actorRole = "狼人",
+            actionDefinitionId = ActionDefinitionId.WEREWOLF_KILL,
+            targets = mutableListOf(3),
+            submittedBy = ActionSubmissionSource.PLAYER,
+            status = ActionStatus.SUBMITTED
+        )
+        val antidote = RoleActionInstance(
+            actor = 2,
+            actorRole = "女巫",
+            actionDefinitionId = ActionDefinitionId.WITCH_ANTIDOTE,
+            targets = mutableListOf(3),
+            submittedBy = ActionSubmissionSource.PLAYER,
+            status = ActionStatus.SUBMITTED
+        )
+
+        val result = executor.executeActions(session, listOf(wolfKill, antidote))
+
+        assertFalse(result.deaths.values.flatten().contains(3), "Villager should be saved by Antidote")
+        assertTrue(result.saved.contains(3), "Villager ID should be in saved list")
+    }
+
+    @Test
+    fun testWitchAntidoteOnGhostRider() {
+        // Wolves target GR (though they shouldn't usually, but for testing logic)
+        val wolfKill = RoleActionInstance(
+            actor = 1,
+            actorRole = "狼人",
+            actionDefinitionId = ActionDefinitionId.WEREWOLF_KILL,
+            targets = mutableListOf(4),
+            submittedBy = ActionSubmissionSource.PLAYER,
+            status = ActionStatus.SUBMITTED
+        )
+        // Witch tries to save GR
+        val antidote = RoleActionInstance(
+            actor = 2,
+            actorRole = "女巫",
+            actionDefinitionId = ActionDefinitionId.WITCH_ANTIDOTE,
+            targets = mutableListOf(4),
+            submittedBy = ActionSubmissionSource.PLAYER,
+            status = ActionStatus.SUBMITTED
+        )
+
+        val result = executor.executeActions(session, listOf(wolfKill, antidote))
+
+        // According to current logic: Witch targets GR -> Reflect!
+        assertTrue(result.deaths[DeathCause.REFLECT]?.contains(2) == true, "Witch should be reflected")
+        // The antidote should NOT have worked because reflection returns accumulatedState (skipping the action)
+        assertFalse(result.saved.contains(4), "Antidote should have been skipped due to reflection")
+
+        // GR is immune to wolf kill at night anyway
+        assertFalse(result.deaths.values.flatten().contains(4), "Ghost Rider should be immune to wolf kill at night")
+    }
+}