pause timer when no player is in a challenge

finreinhard · finreinhard · commit 803c6ecdd780 · 2025-03-22T13:27:10.000+01:00
diff --git a/src/main/kotlin/li/angu/challengeplugin/listeners/PlayerConnectionListener.kt b/src/main/kotlin/li/angu/challengeplugin/listeners/PlayerConnectionListener.kt
@@ -56,8 +56,11 @@ class PlayerConnectionListener(private val plugin: ChallengePluginPlugin) : List
             // Save player data for the challenge
             plugin.playerDataManager.savePlayerData(player, challenge.id)
             
-            // Don't remove player from challenge yet - they should remain in the challenge
-            // data so that when they rejoin they can be put back in the same challenge
+            // Remove the player from the challenge to pause timer if needed
+            challenge.removePlayer(player)
+            
+            // But keep the player in the challenge map for reconnection
+            // The player data is saved and we'll restore it when they reconnect
         }
     }
     
diff --git a/src/main/kotlin/li/angu/challengeplugin/managers/ChallengeManager.kt b/src/main/kotlin/li/angu/challengeplugin/managers/ChallengeManager.kt
@@ -12,6 +12,7 @@ import java.util.UUID
 import java.util.concurrent.ConcurrentHashMap
 import org.bukkit.configuration.file.YamlConfiguration
 import java.io.File
+import java.time.Duration
 import java.time.Instant
 
 class ChallengeManager(private val plugin: ChallengePluginPlugin) {
@@ -49,15 +50,30 @@ class ChallengeManager(private val plugin: ChallengePluginPlugin) {
                     challenge.completedAt = Instant.ofEpochSecond(config.getLong("completedAt"))
                 }
 
+                // Load pause data if it exists
+                if (config.contains("pausedAt")) {
+                    challenge.pausedAt = Instant.ofEpochSecond(config.getLong("pausedAt"))
+                }
+
+                if (config.contains("totalPausedDuration")) {
+                    challenge.totalPausedDuration = Duration.ofSeconds(config.getLong("totalPausedDuration"))
+                }
+
+                if (config.contains("lastEmptyTimestamp")) {
+                    challenge.lastEmptyTimestamp = Instant.ofEpochSecond(config.getLong("lastEmptyTimestamp"))
+                }
+
                 activeChallenges[id] = challenge
 
                 // Update player map
                 challenge.players.forEach { playerId ->
                     playerChallengeMap[playerId] = id
                 }
 
-                // Load world if not loaded
-                loadWorld(challenge.worldName)
+                // Only load world if challenge has players or is recently empty
+                if (challenge.players.isNotEmpty() || !challenge.isReadyForUnload()) {
+                    loadWorld(challenge.worldName)
+                }
             } catch (e: Exception) {
                 plugin.logger.warning("Failed to load challenge from file ${file.name}: ${e.message}")
             }
@@ -77,6 +93,11 @@ class ChallengeManager(private val plugin: ChallengePluginPlugin) {
             challenge.startedAt?.let { config.set("startedAt", it.epochSecond) }
             challenge.completedAt?.let { config.set("completedAt", it.epochSecond) }
 
+            // Save pause data
+            challenge.pausedAt?.let { config.set("pausedAt", it.epochSecond) }
+            config.set("totalPausedDuration", challenge.totalPausedDuration.seconds)
+            challenge.lastEmptyTimestamp?.let { config.set("lastEmptyTimestamp", it.epochSecond) }
+
             config.save(file)
         }
     }
@@ -117,6 +138,21 @@ class ChallengeManager(private val plugin: ChallengePluginPlugin) {
      */
     fun addPlayerToChallenge(playerId: UUID, challengeId: UUID) {
         playerChallengeMap[playerId] = challengeId
+        
+        // This method is called during reconnection, so we need to make sure
+        // the player is also present in the challenge's player set
+        val challenge = activeChallenges[challengeId]
+        if (challenge != null) {
+            // We don't use challenge.addPlayer since that's meant for Player objects
+            // But we want to make sure the player UUID is in the challenge's set
+            challenge.players.add(playerId)
+            
+            // If this is the first player, resume the timer if it was paused
+            if (challenge.players.size == 1 && challenge.pausedAt != null) {
+                challenge.resumeTimer()
+                challenge.lastEmptyTimestamp = null
+            }
+        }
     }
 
     fun joinChallenge(player: Player, challenge: Challenge): Boolean {
diff --git a/src/main/kotlin/li/angu/challengeplugin/models/Challenge.kt b/src/main/kotlin/li/angu/challengeplugin/models/Challenge.kt
@@ -4,6 +4,7 @@ import org.bukkit.World
 import org.bukkit.entity.Player
 import java.util.UUID
 import java.time.Instant
+import java.time.Duration
 import org.bukkit.GameMode
 import li.angu.challengeplugin.utils.TimeFormatter
 
@@ -21,7 +22,10 @@ class Challenge(
     var status: ChallengeStatus = ChallengeStatus.ACTIVE,
     val players: MutableSet<UUID> = mutableSetOf(),
     var completedAt: Instant? = null,
-    var startedAt: Instant? = null
+    var startedAt: Instant? = null,
+    var pausedAt: Instant? = null,
+    var totalPausedDuration: Duration = Duration.ZERO,
+    var lastEmptyTimestamp: Instant? = null
 ) {
     
     fun addPlayer(player: Player): Boolean {
@@ -31,16 +35,35 @@ class Challenge(
         
         val added = players.add(player.uniqueId)
         
-        // If this is the first player, set startedAt
-        if (added && startedAt == null && players.size == 1) {
-            startedAt = Instant.now()
+        // Check if this is the first player (after a pause)
+        if (added && players.size == 1) {
+            // If the challenge was started but paused, resume the timer
+            if (startedAt != null && pausedAt != null) {
+                resumeTimer()
+            } 
+            // If this is the first player ever, set startedAt
+            else if (startedAt == null) {
+                startedAt = Instant.now()
+            }
+            
+            // Reset the lastEmptyTimestamp since we have players now
+            lastEmptyTimestamp = null
         }
         
         return added
     }
     
     fun removePlayer(player: Player): Boolean {
-        return players.remove(player.uniqueId)
+        val removed = players.remove(player.uniqueId)
+        
+        // If there are no players left in the challenge, pause the timer
+        if (removed && players.isEmpty()) {
+            pauseTimer()
+            // Set the timestamp when the challenge became empty
+            lastEmptyTimestamp = Instant.now()
+        }
+        
+        return removed
     }
     
     fun isPlayerInChallenge(player: Player): Boolean {
@@ -57,18 +80,60 @@ class Challenge(
         completedAt = Instant.now()
     }
     
+    fun pauseTimer() {
+        if (pausedAt == null && startedAt != null) {
+            pausedAt = Instant.now()
+        }
+    }
+    
+    fun resumeTimer() {
+        val paused = pausedAt
+        if (paused != null) {
+            // Calculate the duration the timer was paused
+            val pauseDuration = Duration.between(paused, Instant.now())
+            // Add to total paused duration
+            totalPausedDuration = totalPausedDuration.plus(pauseDuration)
+            // Reset the pause timestamp
+            pausedAt = null
+        }
+    }
+    
+    fun getEffectiveDuration(): Duration {
+        if (startedAt == null) {
+            return Duration.ZERO
+        }
+        
+        val end = if (status != ChallengeStatus.ACTIVE && completedAt != null) {
+            completedAt
+        } else if (pausedAt != null) {
+            pausedAt
+        } else {
+            Instant.now()
+        }
+        
+        // Calculate raw duration from start to end
+        val rawDuration = Duration.between(startedAt, end)
+        
+        // Subtract total time paused to get effective duration
+        return rawDuration.minus(totalPausedDuration)
+    }
+    
     fun getFormattedDuration(): String {
         if (startedAt == null) {
             return "Not started"
         }
         
-        // If challenge is completed or failed, show the fixed duration
-        if (status != ChallengeStatus.ACTIVE && completedAt != null) {
-            return TimeFormatter.formatDuration(startedAt!!, completedAt)
-        }
+        // Calculate the effective duration (accounting for pauses)
+        val effectiveDuration = getEffectiveDuration()
         
-        // Otherwise show the current running duration
-        return TimeFormatter.formatDuration(startedAt!!)
+        return TimeFormatter.formatDuration(effectiveDuration)
+    }
+    
+    fun isReadyForUnload(): Boolean {
+        // If the challenge is empty and has been empty for at least 5 minutes
+        return players.isEmpty() && 
+               lastEmptyTimestamp != null && 
+               Duration.between(lastEmptyTimestamp, Instant.now()).toMinutes() >= 5
     }
     
     fun setupPlayerForChallenge(player: Player, world: World) {
diff --git a/src/main/kotlin/li/angu/challengeplugin/tasks/TimerTask.kt b/src/main/kotlin/li/angu/challengeplugin/tasks/TimerTask.kt
@@ -29,7 +29,51 @@ class TimerTask(private val plugin: ChallengePluginPlugin) : BukkitRunnable() {
 
     companion object {
         fun startTimer(plugin: ChallengePluginPlugin) {
+            // Start the timer display task (runs every second)
             TimerTask(plugin).runTaskTimer(plugin, 0L, 20L) // Update every second
+            
+            // Start the world unload check task (runs every minute)
+            WorldUnloadTask(plugin).runTaskTimer(plugin, 20L * 60L, 20L * 60L)
         }
     }
 }
+
+class WorldUnloadTask(private val plugin: ChallengePluginPlugin) : BukkitRunnable() {
+    
+    override fun run() {
+        // Get all active challenges
+        val challenges = plugin.challengeManager.getActiveChallenges()
+        
+        for (challenge in challenges) {
+            // Check if the challenge has been empty for 5+ minutes
+            if (challenge.isReadyForUnload()) {
+                // Unload the challenge world and its associated dimensions
+                unloadChallengeWorlds(challenge.worldName)
+                
+                plugin.logger.info("Unloaded worlds for challenge ${challenge.name} (${challenge.id}) due to inactivity")
+            }
+        }
+    }
+    
+    private fun unloadChallengeWorlds(worldName: String) {
+        // Try to unload the main world
+        val mainWorld = Bukkit.getWorld(worldName)
+        if (mainWorld != null && Bukkit.unloadWorld(mainWorld, true)) {
+            plugin.logger.info("Unloaded main world: $worldName")
+        }
+        
+        // Try to unload the nether world
+        val netherName = "${worldName}_nether"
+        val netherWorld = Bukkit.getWorld(netherName)
+        if (netherWorld != null && Bukkit.unloadWorld(netherWorld, true)) {
+            plugin.logger.info("Unloaded nether world: $netherName")
+        }
+        
+        // Try to unload the end world
+        val endName = "${worldName}_the_end"
+        val endWorld = Bukkit.getWorld(endName)
+        if (endWorld != null && Bukkit.unloadWorld(endWorld, true)) {
+            plugin.logger.info("Unloaded end world: $endName")
+        }
+    }
+}
diff --git a/src/main/kotlin/li/angu/challengeplugin/utils/TimeFormatter.kt b/src/main/kotlin/li/angu/challengeplugin/utils/TimeFormatter.kt
@@ -12,6 +12,10 @@ object TimeFormatter {
             Duration.between(start, Instant.now())
         }
         
+        return formatDuration(duration)
+    }
+    
+    fun formatDuration(duration: Duration): String {
         val days = duration.toDays()
         val hours = duration.toHours() % 24
         val minutes = duration.toMinutes() % 60

Original file line number	Diff line number	Diff line change
`@@ -56,8 +56,11 @@ class PlayerConnectionListener(private val plugin: ChallengePluginPlugin) : List`
`56`	`56`	`// Save player data for the challenge`
`57`	`57`	`plugin.playerDataManager.savePlayerData(player, challenge.id)`
`58`	`58`
`59`		`- // Don't remove player from challenge yet - they should remain in the challenge`
`60`		`- // data so that when they rejoin they can be put back in the same challenge`
	`59`	`+ // Remove the player from the challenge to pause timer if needed`
	`60`	`+ challenge.removePlayer(player)`
	`61`	`+`
	`62`	`+ // But keep the player in the challenge map for reconnection`
	`63`	`+ // The player data is saved and we'll restore it when they reconnect`
`61`	`64`	`}`
`62`	`65`	`}`
`63`	`66`