feat: implement AFK detection and state management for players

twisti-dev · twisti-dev · commit d7ff58b0b4b6 · 2025-04-10T17:52:01.000+02:00
diff --git a/surf-cloud-api/surf-cloud-api-common/src/main/kotlin/dev/slne/surf/cloud/api/common/netty/packet/packet-extension.kt b/surf-cloud-api/surf-cloud-api-common/src/main/kotlin/dev/slne/surf/cloud/api/common/netty/packet/packet-extension.kt
@@ -1,16 +1,17 @@
 package dev.slne.surf.cloud.api.common.netty.packet
 
-import dev.slne.surf.bytebufserializer.Buf
 import dev.slne.surf.cloud.api.common.meta.PacketCodec
 import dev.slne.surf.cloud.api.common.meta.SurfNettyPacket
 import dev.slne.surf.cloud.api.common.netty.network.codec.StreamCodec
 import dev.slne.surf.cloud.api.common.netty.network.codec.StreamDecoder
 import dev.slne.surf.cloud.api.common.netty.network.codec.StreamMemberEncoder
 import dev.slne.surf.cloud.api.common.netty.network.codec.kotlinx.SurfCloudBufSerializer
+import dev.slne.surf.cloud.api.common.netty.protocol.buffer.SurfByteBuf
 import dev.slne.surf.cloud.api.common.util.mutableObject2ObjectMapOf
 import io.netty.buffer.ByteBuf
 import kotlinx.serialization.InternalSerializationApi
 import kotlinx.serialization.KSerializer
+import kotlinx.serialization.serializer
 import kotlinx.serialization.serializerOrNull
 import kotlin.reflect.KClass
 import kotlin.reflect.full.companionObject
@@ -66,6 +67,20 @@ private const val DEFAULT_STREAM_CODEC_NAME = "STREAM_CODEC"
 private val codecCache = mutableObject2ObjectMapOf<KClass<out NettyPacket>, StreamCodec<*, *>>()
 
 
+@OptIn(InternalSerializationApi::class)
+fun <P : NettyPacket> KClass<out P>.createCodec(): StreamCodec<SurfByteBuf, P> {
+    val serializer = serializer()
+    return object : StreamCodec<SurfByteBuf, P> {
+        override fun decode(buf: SurfByteBuf): P {
+            return SurfCloudBufSerializer.serializer.decodeFromBuf(buf, serializer)
+        }
+
+        override fun encode(buf: SurfByteBuf, value: P) {
+            SurfCloudBufSerializer.serializer.encodeToBuf(buf, serializer as KSerializer<P>, value)
+        }
+    }
+}
+
 /**
  * Finds a [StreamCodec] for the specified packet type if available.
  *
diff --git a/surf-cloud-api/surf-cloud-api-common/src/main/kotlin/dev/slne/surf/cloud/api/common/player/CloudPlayer.kt b/surf-cloud-api/surf-cloud-api-common/src/main/kotlin/dev/slne/surf/cloud/api/common/player/CloudPlayer.kt
@@ -35,6 +35,8 @@ interface CloudPlayer : Audience, OfflineCloudPlayer { // TODO: conversation but
      */
     val connected get() = connectedToProxy || connectedToServer
 
+    suspend fun isAfk(): Boolean
+
     /**
      * Performs modifications on the player's persistent data container.
      *
diff --git a/surf-cloud-bukkit/src/main/kotlin/dev/slne/surf/cloud/bukkit/CloudBukkitInstance.kt b/surf-cloud-bukkit/src/main/kotlin/dev/slne/surf/cloud/bukkit/CloudBukkitInstance.kt
@@ -4,8 +4,10 @@ import com.google.auto.service.AutoService
 import dev.slne.surf.cloud.api.common.CloudInstance
 import dev.slne.surf.cloud.bukkit.listener.ListenerManager
 import dev.slne.surf.cloud.bukkit.netty.BukkitNettyManager
+import dev.slne.surf.cloud.bukkit.processor.BukkitListenerProcessor
 import dev.slne.surf.cloud.core.client.ClientCommonCloudInstance
 import dev.slne.surf.cloud.core.common.coreCloudInstance
+import dev.slne.surf.cloud.core.common.util.bean
 import dev.slne.surf.cloud.core.common.util.checkInstantiationByServiceLoader
 
 @AutoService(CloudInstance::class)
@@ -17,6 +19,7 @@ class CloudBukkitInstance : ClientCommonCloudInstance(BukkitNettyManager) {
     override suspend fun onEnable() {
         super.onEnable()
 
+        bean<BukkitListenerProcessor>().registerListeners()
         ListenerManager.registerListeners()
     }
 
diff --git a/surf-cloud-bukkit/src/main/kotlin/dev/slne/surf/cloud/bukkit/listener/player/PlayerAfkListener.kt b/surf-cloud-bukkit/src/main/kotlin/dev/slne/surf/cloud/bukkit/listener/player/PlayerAfkListener.kt
@@ -0,0 +1,62 @@
+package dev.slne.surf.cloud.bukkit.listener.player
+
+import dev.slne.surf.cloud.api.client.netty.packet.fireAndForget
+import dev.slne.surf.cloud.core.common.netty.network.protocol.running.ServerboundUpdateAFKState
+import dev.slne.surf.surfapi.core.api.util.mutableObject2BooleanMapOf
+import dev.slne.surf.surfapi.core.api.util.mutableObject2LongMapOf
+import org.bukkit.event.EventHandler
+import org.bukkit.event.Listener
+import org.bukkit.event.player.PlayerJoinEvent
+import org.bukkit.event.player.PlayerMoveEvent
+import org.bukkit.event.player.PlayerQuitEvent
+import org.springframework.scheduling.annotation.Scheduled
+import org.springframework.stereotype.Component
+import java.util.*
+import java.util.concurrent.TimeUnit
+import kotlin.time.Duration.Companion.seconds
+
+@Component
+class PlayerAfkListener : Listener {
+    private val afkTime = 10.seconds.inWholeMilliseconds
+    private val lastMovedTime = mutableObject2LongMapOf<UUID>()
+    private val currentSentState = mutableObject2BooleanMapOf<UUID>()
+
+    @EventHandler
+    fun onPlayerMove(event: PlayerMoveEvent) {
+        if (!event.hasChangedOrientation()) return
+        if (!event.hasChangedPosition()) return
+        lastMovedTime[event.player.uniqueId] = System.currentTimeMillis()
+    }
+
+    @EventHandler
+    fun onPlayerJoin(event: PlayerJoinEvent) {
+        lastMovedTime[event.player.uniqueId] = System.currentTimeMillis()
+    }
+
+    @EventHandler
+    fun onPlayerQuit(event: PlayerQuitEvent) {
+        val uuid = event.player.uniqueId
+        lastMovedTime.removeLong(uuid)
+        currentSentState.removeBoolean(uuid)
+    }
+
+    @Scheduled(fixedRate = 1, timeUnit = TimeUnit.SECONDS)
+    fun afkCheckTask() {
+        val currentTime = System.currentTimeMillis()
+
+        lastMovedTime.object2LongEntrySet().fastForEach { entry ->
+            val uuid = entry.key
+            val lastMoved = entry.longValue
+            val timeSinceLastMove = currentTime - lastMoved
+            val isAfk = timeSinceLastMove >= afkTime
+            val previousState = currentSentState.put(uuid, isAfk)
+            if (previousState != isAfk) {
+                broadcastChange(uuid, isAfk)
+            }
+        }
+    }
+
+    private fun broadcastChange(uuid: UUID, isAfk: Boolean) {
+        ServerboundUpdateAFKState(uuid, isAfk).fireAndForget()
+    }
+}
diff --git a/surf-cloud-bukkit/src/main/kotlin/dev/slne/surf/cloud/bukkit/processor/BukkitListenerProcessor.kt b/surf-cloud-bukkit/src/main/kotlin/dev/slne/surf/cloud/bukkit/processor/BukkitListenerProcessor.kt
@@ -2,6 +2,7 @@ package dev.slne.surf.cloud.bukkit.processor
 
 import dev.slne.surf.cloud.api.common.util.isAnnotated
 import dev.slne.surf.cloud.api.common.util.isCandidateFor
+import dev.slne.surf.cloud.api.common.util.mutableObjectListOf
 import dev.slne.surf.cloud.api.common.util.selectFunctions
 import dev.slne.surf.cloud.api.common.util.ultimateTargetClass
 import org.bukkit.Bukkit
@@ -21,6 +22,8 @@ import java.lang.reflect.Method
 
 @Component
 class BukkitListenerProcessor : BeanPostProcessor {
+    private val listeners = mutableObjectListOf<ListenerMetaData>()
+
     override fun postProcessAfterInitialization(bean: Any, beanName: String): Any {
         if (bean is AopInfrastructureBean) return bean
 
@@ -52,7 +55,7 @@ class BukkitListenerProcessor : BeanPostProcessor {
             }
 
             val eventParam = params[0]
-            if (!eventParam.isAssignableFrom(Event::class.java)) {
+            if (!Event::class.java.isAssignableFrom(eventParam)) {
                 throw BeanCreationException(
                     beanName,
                     "Event handler method parameter must be a subclass of Event"
@@ -77,7 +80,26 @@ class BukkitListenerProcessor : BeanPostProcessor {
                     throw EventException(e, "Error invoking event handler")
                 }
             }
-            registerEventHandler(bean, eventClass, eventHandler, eventExecutor)
+
+            listeners.add(
+                ListenerMetaData(
+                    bean,
+                    eventClass,
+                    eventHandler,
+                    eventExecutor
+                )
+            )
+        }
+    }
+
+    fun registerListeners() {
+        for (listener in listeners) {
+            registerEventHandler(
+                listener.bean,
+                listener.event,
+                listener.eventHandler,
+                listener.eventExecutor
+            )
         }
     }
 
@@ -104,4 +126,11 @@ class BukkitListenerProcessor : BeanPostProcessor {
     private fun getPluginFromBean(bean: Any): JavaPlugin {
         return JavaPlugin.getProvidingPlugin(bean.javaClass)
     }
+
+    data class ListenerMetaData(
+        val bean: Any,
+        val event: Class<out Event>,
+        val eventHandler: EventHandler,
+        val eventExecutor: EventExecutor
+    )
 }
diff --git a/surf-cloud-core/surf-cloud-core-client/src/main/kotlin/dev/slne/surf/cloud/core/client/player/ClientCloudPlayerImpl.kt b/surf-cloud-core/surf-cloud-core-client/src/main/kotlin/dev/slne/surf/cloud/core/client/player/ClientCloudPlayerImpl.kt
@@ -49,7 +49,6 @@ abstract class ClientCloudPlayerImpl<PlatformPlayer : Audience>(uuid: UUID) :
     override val connectedToProxy get() = proxyServerUid != null
 
     override val connectedToServer get() = serverUid != null
-
     /**
      * The audience for this player. If the player is on this server, this will point to
      * the bukkit / velocity player. Otherwise packets will be sent to the player via the network.
@@ -74,6 +73,10 @@ abstract class ClientCloudPlayerImpl<PlatformPlayer : Audience>(uuid: UUID) :
         return request<FirstSeen>(DataRequestType.FIRST_SEEN).firstSeen
     }
 
+    override suspend fun isAfk(): Boolean {
+        return request<IsAFK>(DataRequestType.IS_AFK).isAfk
+    }
+
     override suspend fun <R> withPersistentData(block: PersistentPlayerDataContainer.() -> R): R {
         val response = ServerboundRequestPlayerPersistentDataContainer(uuid).fireAndAwaitOrThrow()
 
diff --git a/surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/netty/network/ConnectionImpl.kt b/surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/netty/network/ConnectionImpl.kt
@@ -343,6 +343,7 @@ class ConnectionImpl(
                         is TeleportPlayerPacket -> listener.handleTeleportPlayer(msg)
                         is ServerboundShutdownServerPacket -> listener.handleShutdownServer(msg)
                         is ServerboundRequestPlayerDataPacket -> listener.handleRequestPlayerData(msg)
+                        is ServerboundUpdateAFKState -> listener.handleUpdateAFKState(msg)
 
                         else -> listener.handlePacket(msg) // handle other packets
                     }
diff --git a/surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/netty/network/protocol/running/RunningProtocols.kt b/surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/netty/network/protocol/running/RunningProtocols.kt
@@ -1,6 +1,8 @@
 package dev.slne.surf.cloud.core.common.netty.network.protocol.running
 
 import dev.slne.surf.cloud.api.common.netty.network.ConnectionProtocol
+import dev.slne.surf.cloud.api.common.netty.packet.createCodec
+import dev.slne.surf.cloud.api.common.netty.packet.findPacketCodec
 import dev.slne.surf.cloud.api.common.netty.protocol.buffer.SurfByteBuf
 import dev.slne.surf.cloud.core.common.netty.network.protocol.ProtocolInfoBuilder
 import dev.slne.surf.cloud.core.common.netty.network.protocol.common.*
@@ -95,6 +97,7 @@ object RunningProtocols {
                 .addPacket(ServerboundShutdownServerPacket.STREAM_CODEC)
                 .addPacket(RequestOfflineDisplayNamePacket.STREAM_CODEC)
                 .addPacket(ServerboundRequestPlayerDataPacket.STREAM_CODEC)
+                .addPacket(ServerboundUpdateAFKState::class.createCodec())
         }
 
     val SERVERBOUND by lazy { SERVERBOUND_TEMPLATE.freeze().bind(::SurfByteBuf) }
diff --git a/surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/netty/network/protocol/running/RunningServerPacketListener.kt b/surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/netty/network/protocol/running/RunningServerPacketListener.kt
@@ -63,6 +63,8 @@ interface RunningServerPacketListener : ServerCommonPacketListener, TickablePack
     suspend fun handleShutdownServer(packet: ServerboundShutdownServerPacket)
 
     suspend fun handleRequestPlayerData(packet: ServerboundRequestPlayerDataPacket)
+
+    fun handleUpdateAFKState(packet: ServerboundUpdateAFKState)
     
     fun handlePacket(packet: NettyPacket)
 }
diff --git a/surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/netty/network/protocol/running/ServerboundRequestPlayerDataPacket.kt b/surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/netty/network/protocol/running/ServerboundRequestPlayerDataPacket.kt
@@ -81,6 +81,12 @@ class ServerboundRequestPlayerDataPacket(val uuid: UUID, val type: DataRequestTy
             override suspend fun readData(player: OfflineCloudPlayer): DataResponse {
                 return Playtime(player.playtime())
             }
+        },
+        IS_AFK(::IsAFK) {
+            override suspend fun readData(player: OfflineCloudPlayer): DataResponse {
+                val player= player.player ?: error("Player is not online")
+                return IsAFK(player.isAfk())
+            }
         };
 
         abstract suspend fun readData(player: OfflineCloudPlayer): DataResponse
@@ -174,6 +180,14 @@ class ServerboundRequestPlayerDataResponse(val data: DataResponse) : ResponseNet
             playtime.writeToByteBuf(buf)
         }
     }
+
+    class IsAFK(val isAfk: Boolean) : DataResponse(DataRequestType.IS_AFK) {
+        constructor(buf: SurfByteBuf) : this(buf.readBoolean())
+
+        override fun write(buf: SurfByteBuf) {
+            buf.writeBoolean(isAfk)
+        }
+    }
 }
 
 inline fun <reified T> DataResponse.getGenericValue(): T = when (this) {
@@ -185,5 +199,6 @@ inline fun <reified T> DataResponse.getGenericValue(): T = when (this) {
     is Name -> check(T::class == String::class) { "Expected String" }.let { name as T }
     is NameHistory -> check(T::class == ApiNameHistory::class) { "Expected ApiNameHistory" }.let { history as T }
     is Playtime -> check(T::class == ApiPlaytime::class) { "Expected ApiPlaytime" }.let { playtime as T }
+    is IsAFK -> check(T::class == Boolean::class) { "Expected Boolean" }.let { isAfk as T }
     else -> error("Unknown DataResponse type: ${this::class.simpleName}")
 }
diff --git a/surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/netty/network/protocol/running/ServerboundUpdateAFKState.kt b/surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/netty/network/protocol/running/ServerboundUpdateAFKState.kt
@@ -0,0 +1,12 @@
+package dev.slne.surf.cloud.core.common.netty.network.protocol.running
+
+import dev.slne.surf.cloud.api.common.meta.SurfNettyPacket
+import dev.slne.surf.cloud.api.common.netty.network.protocol.PacketFlow
+import dev.slne.surf.cloud.api.common.netty.packet.NettyPacket
+import kotlinx.serialization.Contextual
+import kotlinx.serialization.Serializable
+import java.util.*
+
+@SurfNettyPacket("cloud:serverbound:update_afk_state", PacketFlow.SERVERBOUND)
+@Serializable
+class ServerboundUpdateAFKState(val uuid: @Contextual UUID, val isAfk: Boolean) : NettyPacket()
diff --git a/surf-cloud-standalone/src/main/kotlin/dev/slne/surf/cloud/standalone/netty/server/network/ServerRunningPacketListenerImpl.kt b/surf-cloud-standalone/src/main/kotlin/dev/slne/surf/cloud/standalone/netty/server/network/ServerRunningPacketListenerImpl.kt
@@ -279,6 +279,10 @@ class ServerRunningPacketListenerImpl(
         )
     }
 
+    override fun handleUpdateAFKState(packet: ServerboundUpdateAFKState) {
+        withPlayer(packet.uuid) { updateAfkStatus(packet.isAfk) }
+    }
+
     override fun handlePacket(packet: NettyPacket) {
         val listeners = NettyListenerRegistry.getListeners(packet.javaClass) ?: return
         if (listeners.isEmpty()) return
diff --git a/surf-cloud-standalone/src/main/kotlin/dev/slne/surf/cloud/standalone/player/CloudPlayerPlaytimeManager.kt b/surf-cloud-standalone/src/main/kotlin/dev/slne/surf/cloud/standalone/player/CloudPlayerPlaytimeManager.kt
@@ -66,6 +66,7 @@ class CloudPlayerPlaytimeManager(private val service: CloudPlayerService) : Disp
                     sessions[uuid] = newSession
                     toCreate += uuid to newSession
                 } else {
+                    if (player.afk) return@forEach
                     // Just increment current session
                     currentSession.accumulatedSeconds++
                 }
diff --git a/surf-cloud-standalone/src/main/kotlin/dev/slne/surf/cloud/standalone/player/StandaloneCloudPlayerImpl.kt b/surf-cloud-standalone/src/main/kotlin/dev/slne/surf/cloud/standalone/player/StandaloneCloudPlayerImpl.kt
@@ -21,6 +21,7 @@ import dev.slne.surf.cloud.core.common.util.bean
 import dev.slne.surf.cloud.standalone.player.db.exposed.CloudPlayerService
 import dev.slne.surf.cloud.standalone.server.StandaloneCloudServerImpl
 import dev.slne.surf.cloud.standalone.server.StandaloneProxyCloudServerImpl
+import dev.slne.surf.surfapi.core.api.messages.adventure.sendText
 import dev.slne.surf.surfapi.core.api.util.logger
 import dev.slne.surf.surfapi.core.api.util.mutableObjectListOf
 import dev.slne.surf.surfapi.core.api.util.toObjectList
@@ -79,10 +80,13 @@ class StandaloneCloudPlayerImpl(uuid: UUID, val name: String, val ip: Inet4Addre
         private set
 
     private val ppdc = PersistentPlayerDataContainerImpl()
-    private val ppdcMutex = Mutex()
 
+    private val ppdcMutex = Mutex()
     private var firstSeenCache: ZonedDateTime? = null
 
+    var afk = false
+        private set
+
     fun savePlayerData(tag: CompoundTag) {
         if (!ppdc.empty) {
             tag.put("ppdc", ppdc.toTagCompound())
@@ -96,6 +100,25 @@ class StandaloneCloudPlayerImpl(uuid: UUID, val name: String, val ip: Inet4Addre
         }
     }
 
+    override suspend fun isAfk(): Boolean {
+        return afk
+    }
+
+    fun updateAfkStatus(newValue: Boolean) {
+        if (newValue == afk) return
+        afk = newValue
+
+        sendText {
+            appendPrefix()
+            info("Du bist nun ")
+            if (afk) {
+                info("AFK und erhältst keine weiteren Paychecks.")
+            } else {
+                info("nicht mehr AFK.")
+            }
+        }
+    }
+
     override suspend fun <R> withPersistentData(block: PersistentPlayerDataContainer.() -> R): R =
         ppdcMutex.withLock {
             ppdc.block()

Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,8 @@ interface CloudPlayer : Audience, OfflineCloudPlayer { // TODO: conversation but`
`35`	`35`	`*/`
`36`	`36`	`val connected get() = connectedToProxy \|\| connectedToServer`
`37`	`37`
	`38`	`+ suspend fun isAfk(): Boolean`
	`39`	`+`
`38`	`40`	`/**`
`39`	`41`	`* Performs modifications on the player's persistent data container.`
`40`	`42`	`*`
Original file line number	Diff line number	Diff line change
`@@ -343,6 +343,7 @@ class ConnectionImpl(`
`343`	`343`	`is TeleportPlayerPacket -> listener.handleTeleportPlayer(msg)`
`344`	`344`	`is ServerboundShutdownServerPacket -> listener.handleShutdownServer(msg)`
`345`	`345`	`is ServerboundRequestPlayerDataPacket -> listener.handleRequestPlayerData(msg)`
	`346`	`+ is ServerboundUpdateAFKState -> listener.handleUpdateAFKState(msg)`
`346`	`347`
`347`	`348`	`else -> listener.handlePacket(msg) // handle other packets`
`348`	`349`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,6 +63,8 @@ interface RunningServerPacketListener : ServerCommonPacketListener, TickablePack`
`63`	`63`	`suspend fun handleShutdownServer(packet: ServerboundShutdownServerPacket)`
`64`	`64`
`65`	`65`	`suspend fun handleRequestPlayerData(packet: ServerboundRequestPlayerDataPacket)`
	`66`	`+`
	`67`	`+ fun handleUpdateAFKState(packet: ServerboundUpdateAFKState)`
`66`	`68`
`67`	`69`	`fun handlePacket(packet: NettyPacket)`
`68`	`70`	`}`