feat: optional player synchronization

Author: FllipEis

build.gradle.kts

@@ -9,7 +9,7 @@ plugins {
     `maven-publish`
 }
 
-val baseVersion = "0.0.5"
+val baseVersion = "0.0.6"
 val commitHash = System.getenv("COMMIT_HASH")
 val timestamp = System.currentTimeMillis() // Temporary to be able to build and publish directly out of fix branch with same commit hash
 val snapshotVersion = "${baseVersion}-dev.${timestamp}-${commitHash}"

gradle/libs.versions.toml

@@ -1,6 +1,6 @@
 [versions]
 kotlin = "2.1.20"
-kotlin-coroutines = "1.10.1"
+kotlin-coroutines = "1.10.2"
 velocity = "3.4.0-SNAPSHOT"
 bungeecord = "1.20-R0.2-SNAPSHOT"
 shadow = "8.3.3"

platform/bungeecord/build.gradle.kts

@@ -9,6 +9,7 @@ dependencies {
     implementation(rootProject.libs.kotlin.reflect)
     implementation(rootProject.libs.kotlin.coroutines)
     compileOnly(rootProject.libs.bungeecord)
+    compileOnly(project(":platform:shared"))
     api(rootProject.libs.simplecloud.controller) {
         exclude(group = "org.jetbrains.kotlin")
         exclude(group = "org.jetbrains.kotlinx")

platform/bungeecord/src/main/kotlin/app/simplecloud/api/platform/bungeecord/BungeeCordApiProvider.kt

@@ -1,14 +1,24 @@
 package app.simplecloud.api.platform.bungeecord
 
+import app.simplecloud.api.platform.shared.PlayerSynchronizer
+import app.simplecloud.controller.api.ControllerApi
 import net.md_5.bungee.api.plugin.Plugin
 
 class BungeeCordApiProvider : Plugin() {
+
+    private val controllerApi = ControllerApi.createCoroutineApi()
+    private val playerSynchronizer = PlayerSynchronizer(controllerApi) { proxy.onlineCount.toLong() }
+
     override fun onEnable() {
         logger.info("SimpleCloud v3 API provider initialized!")
+        proxy.pluginManager.registerListener( this, PlayerConnectionListener(playerSynchronizer))
+
+        playerSynchronizer.start()
     }
 
     override fun onDisable() {
         logger.info("SimpleCloud v3 API provider uninitialized!")
+        playerSynchronizer.stop()
     }
 
 }

platform/bungeecord/src/main/kotlin/app/simplecloud/api/platform/bungeecord/PlayerConnectionListener.kt

@@ -0,0 +1,30 @@
+package app.simplecloud.api.platform.bungeecord
+
+import app.simplecloud.api.platform.shared.PlayerSynchronizer
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import net.md_5.bungee.api.event.PlayerDisconnectEvent
+import net.md_5.bungee.api.event.PostLoginEvent
+import net.md_5.bungee.api.plugin.Listener
+import net.md_5.bungee.event.EventHandler
+
+class PlayerConnectionListener(
+    private val playerSynchronizer: PlayerSynchronizer
+) : Listener {
+
+    @EventHandler
+    fun onPlayerJoin(event: PostLoginEvent) {
+        CoroutineScope(Dispatchers.Default).launch {
+            playerSynchronizer.updatePlayerCount()
+        }
+    }
+
+    @EventHandler
+    fun onPlayerQuit(event: PlayerDisconnectEvent) {
+        CoroutineScope(Dispatchers.Default).launch {
+            playerSynchronizer.updatePlayerCount()
+        }
+    }
+
+}

platform/paper/build.gradle.kts

@@ -3,6 +3,7 @@ import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 dependencies {
     implementation(rootProject.libs.kotlin.stdlib)
     compileOnly(rootProject.libs.paper.api)
+    implementation(project(":platform:shared"))
 }
 
 sourceSets.main {

platform/shared/build.gradle.kts

@@ -0,0 +1,14 @@
+dependencies {
+    compileOnly(rootProject.libs.kotlin.stdlib)
+    compileOnly(rootProject.libs.kotlin.reflect)
+    compileOnly(rootProject.libs.kotlin.coroutines)
+    compileOnly(rootProject.libs.simplecloud.controller) {
+        exclude(group = "org.jetbrains.kotlin")
+        exclude(group = "org.jetbrains.kotlinx")
+    }
+    compileOnly(rootProject.libs.simplecloud.player) {
+        exclude(group = "net.kyori")
+        exclude(group = "org.jetbrains.kotlin")
+        exclude(group = "org.jetbrains.kotlinx")
+    }
+}

platform/shared/src/main/kotlin/app/simplecloud/api/platform/shared/PlayerSynchronizer.kt

@@ -0,0 +1,52 @@
+package app.simplecloud.api.platform.shared
+
+import app.simplecloud.controller.api.ControllerApi
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+import kotlin.time.Duration.Companion.seconds
+
+class PlayerSynchronizer(
+    private val controllerApi: ControllerApi.Coroutine,
+    private val getCurrentOnlineCount: () -> Long,
+) {
+
+    private val currentServerId = System.getenv("SIMPLECLOUD_UNIQUE_ID")
+
+    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    private val updateFlow = MutableSharedFlow<Unit>()
+
+    @OptIn(FlowPreview::class)
+    fun start() {
+        scope.launch {
+            controllerApi.getServers().updateServerProperty(currentServerId, "player-count-ping", "skip")
+        }
+
+        scope.launch {
+            updateFlow
+                .debounce(800)
+                .collect {
+                    val currentServer = controllerApi.getServers().getCurrentServer().copy(
+                        playerCount = getCurrentOnlineCount()
+                    )
+                    controllerApi.getServers().updateServer(currentServer)
+                    println("Updated server player count to ${currentServer.playerCount}")
+                }
+        }
+
+        scope.launch {
+            while (isActive) {
+                updatePlayerCount()
+                delay(15.seconds)
+            }
+        }
+    }
+
+    suspend fun updatePlayerCount() {
+        updateFlow.emit(Unit)
+    }
+
+    fun stop() {
+        scope.cancel()
+    }
+
+}

platform/spigot/build.gradle.kts

@@ -7,6 +7,8 @@ plugins {
 dependencies {
     compileOnly(rootProject.libs.kotlin.stdlib)
     compileOnly(rootProject.libs.kotlin.reflect)
+    compileOnly(rootProject.libs.kotlin.coroutines)
+    api(project(":platform:shared"))
     compileOnly(rootProject.libs.paper.api)
     api(rootProject.libs.simplecloud.controller) {
         exclude(group = "org.jetbrains.kotlin")

platform/spigot/src/main/kotlin/app/simplecloud/api/platform/spigot/PlayerConnectionListener.kt

@@ -0,0 +1,30 @@
+package app.simplecloud.api.platform.spigot
+
+import app.simplecloud.api.platform.shared.PlayerSynchronizer
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import org.bukkit.event.EventHandler
+import org.bukkit.event.Listener
+import org.bukkit.event.player.PlayerJoinEvent
+import org.bukkit.event.player.PlayerQuitEvent
+
+class PlayerConnectionListener(
+    private val playerSynchronizer: PlayerSynchronizer
+) : Listener {
+
+    @EventHandler
+    fun onPlayerJoin(event: PlayerJoinEvent) {
+        CoroutineScope(Dispatchers.Default).launch {
+            playerSynchronizer.updatePlayerCount()
+        }
+    }
+
+    @EventHandler
+    fun onPlayerQuit(event: PlayerQuitEvent) {
+        CoroutineScope(Dispatchers.Default).launch {
+            playerSynchronizer.updatePlayerCount()
+        }
+    }
+
+}