housekeeping

Author: RobotHanzo

src/main/kotlin/dev/robothanzo/werewolf/game/model/ActionDefinitionId.kt

@@ -54,12 +54,5 @@ enum class ActionDefinitionId(val actionName: String) {
         fun fromString(id: String): ActionDefinitionId? {
             return entries.find { it.toString() == id }
         }
-
-        /**
-         * Check if a string ID is valid
-         */
-        fun isValid(id: String): Boolean {
-            return entries.any { it.toString() == id }
-        }
     }
 }

src/main/kotlin/dev/robothanzo/werewolf/game/model/GameStateData.kt

@@ -52,15 +52,6 @@ data class RoleActionInstance(
     var targetPromptId: Long? = null // Discord message ID for target selection prompt
 )
 
-data class ActionSubmissionStatus(
-    val playerId: Int,
-    val role: String,
-    val status: ActionStatus, // PENDING, ACTING, SUBMITTED, SKIPPED
-    val actionType: String? = null, // The action chosen (e.g., "KILL", "HEAL", "CHECK")
-    val targetId: String? = null,
-    val submittedAt: Long? = null
-)
-
 /**
  * Group action state for coordinated actions like wolf kills
  */

src/main/kotlin/dev/robothanzo/werewolf/game/roles/actions/DreamWeaverAction.kt

@@ -18,8 +18,7 @@ class DreamWeaverLinkAction : BaseRoleAction(
     ): ActionExecutionResult {
         if (action.targets.isEmpty()) return accumulatedState
         val targetId = action.targets.firstOrNull() ?: return accumulatedState
-        val target = session.getPlayer(targetId) ?: return accumulatedState
-        
+
         // Record the target for this day
         session.stateData.dreamWeaverTargets[session.day] = targetId
 

src/test/kotlin/dev/robothanzo/werewolf/game/DreamWeaverNightmareTest.kt

@@ -4,30 +4,28 @@ import dev.robothanzo.werewolf.WerewolfApplication
 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.PredefinedRoles
 import dev.robothanzo.werewolf.game.roles.RoleRegistry
 import dev.robothanzo.werewolf.game.roles.actions.ActionExecutionResult
 import dev.robothanzo.werewolf.game.roles.actions.DeathResolutionAction
 import dev.robothanzo.werewolf.game.roles.actions.RoleActionExecutor
 import dev.robothanzo.werewolf.service.GameSessionService
-import org.junit.jupiter.api.Assertions.*
+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
 import org.junit.jupiter.api.extension.ExtendWith
 import org.mockito.Mock
-import org.mockito.Mockito.`when`
 import org.mockito.junit.jupiter.MockitoExtension
-import java.util.*
 
 @ExtendWith(MockitoExtension::class)
 class DreamWeaverNightmareTest {
 
     private lateinit var session: Session
     private lateinit var roleRegistry: RoleRegistry
-    
+
     @Mock
     private lateinit var roleActionExecutor: RoleActionExecutor
-    
+
     @Mock
     private lateinit var gameSessionService: GameSessionService
 
@@ -36,26 +34,26 @@ class DreamWeaverNightmareTest {
         session = Session()
         session.stateData = GameStateData()
         session.day = 1
-        
+
         // Setup static mocks
         WerewolfApplication.gameSessionService = gameSessionService
-        
+
         // Setup Players
         val dw = Player(id = 1).apply { roles.add("攝夢人") }
         val nm = Player(id = 2).apply { roles.add("夢魘") } // Nightmare is wolf team but role logic handles it
-        nm.roles.add("狼人") // Add generic wolf role just in case or depend on Nightmare being wolf? 
+        nm.roles.add("狼人") // Add generic wolf role just in case or depend on Nightmare being wolf?
         // Nightmare should be a wolf role. PredefinedRoles? GameData?
         // In Player.isWolf, it checks: role.contains("狼") || role == "石像鬼" || role == "血月使者" || role == "惡靈騎士"
         // Nightmare is new. Does Player.isWolf know about it?
         // Player.kt: fun isWolf(role: String) { return role.contains("狼") || ... }
         // "夢魘" does not contain "狼". I should update Player.kt OR just add "狼人" to roles for test simplicity.
-        // Let's check Player.kt isWolf again. 
+        // Let's check Player.kt isWolf again.
         // It has hardcoded list. I need to update it for Nightmare too?
         // Or just add "狼人" as secondary role in test to make it simple.
-        
+
         val villager = Player(id = 3).apply { roles.add("平民") }
         val wolf = Player(id = 4).apply { roles.add("狼人") }
-        
+
         session.addPlayer(dw)
         session.addPlayer(nm)
         session.addPlayer(villager)
@@ -66,132 +64,155 @@ class DreamWeaverNightmareTest {
     fun testWolfFearBlocksCamp() {
         // Nightmare (ID 2) fears the Wolf (ID 4)
         session.stateData.nightmareFearTargets[1] = 4
-        
+
         // This is the logic used in NightStep to filter wolves
         val fearedId = session.stateData.nightmareFearTargets[session.day]
         val isAnyWolfFeared = fearedId != null && session.getPlayer(fearedId)?.wolf == true
-        
+
         assertTrue(isAnyWolfFeared, "Wolf should be detected as feared if teammate is nightmared")
-        
+
         // The list of werewolves allowed to vote should be empty in NightStep if this is true
-        val werewolves = if (isAnyWolfFeared) emptyList<Int>() else session.players.values.filter { it.wolf }.map { it.id }
+        val werewolves =
+            if (isAnyWolfFeared) emptyList<Int>() else session.players.values.filter { it.wolf }.map { it.id }
         assertTrue(werewolves.isEmpty(), "Werewolf voting list should be empty if a wolf is nightmared")
     }
 
     @Test
     fun testDreamWeaverImmunity() {
         // Day 1: Dream Weaver links Villager
         session.stateData.dreamWeaverTargets[1] = 3
-        
+
         // Wolf kills Villager
         val executionResult = ActionExecutionResult()
         executionResult.deaths.getOrPut(DeathCause.WEREWOLF) { mutableListOf() }.add(3)
-        
+
         // Run Death Resolution
         val resolutionAction = DeathResolutionAction()
-        val result = resolutionAction.execute(session, RoleActionInstance(0, "", null, mutableListOf(), ActionSubmissionSource.SYSTEM, ActionStatus.PROCESSED), executionResult)
-        
+        val result = resolutionAction.execute(
+            session,
+            RoleActionInstance(0, "", null, mutableListOf(), ActionSubmissionSource.SYSTEM, ActionStatus.PROCESSED),
+            executionResult
+        )
+
         // Villager should NOT be in deaths (Immunity)
-        assertFalse(result.deaths[DeathCause.WEREWOLF]?.contains(3) == true, "Villager should be immune to Wolf kill due to Dream Weaver")
+        assertFalse(
+            result.deaths[DeathCause.WEREWOLF]?.contains(3) == true,
+            "Villager should be immune to Wolf kill due to Dream Weaver"
+        )
     }
 
     @Test
     fun testDreamWeaverConsecutiveDeath() {
         // Day 1: Dream Weaver links Villager (done in history)
         session.stateData.dreamWeaverTargets[1] = 3
-        
+
         // Day 2
         session.day = 2
         // Dream Weaver links Villager AGAIN
         session.stateData.dreamWeaverTargets[2] = 3
-        
+
         val executionResult = ActionExecutionResult()
-        
+
         // Run Death Resolution
         val resolutionAction = DeathResolutionAction()
-        val result = resolutionAction.execute(session, RoleActionInstance(0, "", null, mutableListOf(), ActionSubmissionSource.SYSTEM, ActionStatus.PROCESSED), executionResult)
-        
+        val result = resolutionAction.execute(
+            session,
+            RoleActionInstance(0, "", null, mutableListOf(), ActionSubmissionSource.SYSTEM, ActionStatus.PROCESSED),
+            executionResult
+        )
+
         // Villager should die from Dream Weaver
-        assertTrue(result.deaths[DeathCause.DREAM_WEAVER]?.contains(3) == true, "Villager should die due to consecutive Dream Weaver link")
+        assertTrue(
+            result.deaths[DeathCause.DREAM_WEAVER]?.contains(3) == true,
+            "Villager should die due to consecutive Dream Weaver link"
+        )
     }
 
     @Test
     fun testDreamWeaverLinkedDeath() {
         // Day 1: Dream Weaver links Villager
         session.stateData.dreamWeaverTargets[1] = 3
-        
+
         // Dream Weaver dies (e.g. Wolf kill)
         val executionResult = ActionExecutionResult()
         executionResult.deaths.getOrPut(DeathCause.WEREWOLF) { mutableListOf() }.add(1) // 1 is DW
-        
+
         // Run Death Resolution
         val resolutionAction = DeathResolutionAction()
-        val result = resolutionAction.execute(session, RoleActionInstance(0, "", null, mutableListOf(), ActionSubmissionSource.SYSTEM, ActionStatus.PROCESSED), executionResult)
-        
+        val result = resolutionAction.execute(
+            session,
+            RoleActionInstance(0, "", null, mutableListOf(), ActionSubmissionSource.SYSTEM, ActionStatus.PROCESSED),
+            executionResult
+        )
+
         // Dream Weaver dies
         assertTrue(result.deaths[DeathCause.WEREWOLF]?.contains(1) == true)
         // Villager should also die (Linked Death)
-        assertTrue(result.deaths[DeathCause.DREAM_WEAVER]?.contains(3) == true, "Villager should die because Dream Weaver died")
+        assertTrue(
+            result.deaths[DeathCause.DREAM_WEAVER]?.contains(3) == true,
+            "Villager should die because Dream Weaver died"
+        )
     }
 
     @Test
     fun testNightmareFearRestriction() {
         // Day 1 night: Nightmare fears Villager (ID 3)
         session.stateData.nightmareFearTargets[1] = 3
         session.currentState = "NIGHT_PHASE"
-        
+
         // Villager tries to use skill? (e.g. if Villager was Seer)
         // Here we test SessionExtensions.isActionAvailable manually or mock logic
         // But since I modified SessionExtensions, I can test the logic directly if I can invoke extension method.
         // Assuming test can call extension method:
-        
+
         // Let's pretend Villager is Seer for this test
         val seer = Player(id = 5).apply { roles.add("預言家") }
         session.addPlayer(seer)
-        
+
         // Fear Seer
         session.stateData.nightmareFearTargets[1] = 5
-        
+
         // Create a dummy Seer Action
-        val actionId = ActionDefinitionId.SEER_CHECK
-        
+        ActionDefinitionId.SEER_CHECK
+
         // To test isActionAvailable, we need RoleRegistry mock
         // Instead of full registry, let's just inspect the logic we added:
         // if (fearedId == playerId && isNightPhase) return false
-        
-        // I will reproduce the logic here to verify my understanding/implementation or use reflection if needed, 
+
+        // I will reproduce the logic here to verify my understanding/implementation or use reflection if needed,
         // but ideally I should call the actual method.
-        // Since I cannot easily compile extensions in this test snippet without full context setup, 
+        // Since I cannot easily compile extensions in this test snippet without full context setup,
         // I will trust the logic `if (fearedId == playerId && isNightPhase) return false` which is simple.
-        
+
         // Instead, let's test Werewolf Kill restriction
         // Nightmare fears Wolf (ID 4)
         session.stateData.nightmareFearTargets[1] = 4
-        
+
         // Helper to simulate Wolf Kill execution
         val killActionInstance = RoleActionInstance(
-            actor = 4, 
-            actorRole = "WEREWOLF", 
+            actor = 4,
+            actorRole = "WEREWOLF",
             actionDefinitionId = ActionDefinitionId.WEREWOLF_KILL,
             targets = mutableListOf(3), // Try to kill Villager
             submittedBy = ActionSubmissionSource.PLAYER,
             status = ActionStatus.SUBMITTED
         )
-        
+
         // Use a real WerewolfKillAction (or anonymous subclass if needed)
         // I need to instantiate WerewolfKillAction. Since it's a class, I can just new it.
         val wolfKillAction = dev.robothanzo.werewolf.game.roles.actions.WerewolfKillAction()
-        
+
         val executionResult = ActionExecutionResult()
-        
+
         val result = wolfKillAction.execute(session, killActionInstance, executionResult)
-        
+
         // Result should NOT have death because wolf teammate is feared
         assertFalse(result.deaths.containsKey(DeathCause.WEREWOLF), "Wolf kill should fail if teammate is feared")
-        
+
         // Verify log is added (mock session addLog?)
         // assert(session.logs.isNotEmpty()) // Mocking logs might be hard with just data class
     }
+
     @Test
     fun testNightmareActionIsCompulsory() {
         val action = dev.robothanzo.werewolf.game.roles.actions.NightmareFearAction()

src/test/kotlin/dev/robothanzo/werewolf/service/impl/ActionUIServiceImplTest.kt

@@ -157,7 +157,7 @@ class ActionUIServiceImplTest {
         )
 
         // Mock role to return actions
-        val mockRole = mock<dev.robothanzo.werewolf.game.model.Role>()
+        val mockRole = mock<Role>()
         whenever(mockRole.getActions()).thenReturn(listOf(mandatoryRoleAction))
         whenever(roleRegistry.getRole("狼弟")).thenReturn(mockRole)
         whenever(roleRegistry.getAction(ActionDefinitionId.WOLF_YOUNGER_BROTHER_EXTRA_KILL)).thenReturn(
@@ -228,7 +228,7 @@ class ActionUIServiceImplTest {
             targets = { _, _, _ -> listOf(targetId) }
         )
 
-        val mockRole = mock<dev.robothanzo.werewolf.game.model.Role>()
+        val mockRole = mock<Role>()
         whenever(mockRole.getActions()).thenReturn(listOf(mandatoryRoleAction))
         whenever(roleRegistry.getRole("預言家")).thenReturn(mockRole)
         whenever(roleRegistry.getAction(ActionDefinitionId.SEER_CHECK)).thenReturn(mandatoryRoleAction)