feat: implement player mute synchronization task and supporting packets

- Added `SynchronizePlayerPunishmentManagers` task for synchronizing player mute data.
- Introduced `ClientboundSynchronizePlayerMutes` packet with supporting `STREAM_CODEC`.
- Updated synchronization protocols to include new packet type.
- Expanded punishment manager with methods to manage raw cached mutes.
- Enhanced server-client packet listeners to handle and process mute synchronization.

Author: twisti-dev

surf-cloud-core/surf-cloud-core-client/src/main/kotlin/dev/slne/surf/cloud/core/client/netty/network/ClientSynchronizingPacketListenerImpl.kt

@@ -246,6 +246,18 @@ class ClientSynchronizingPacketListenerImpl(
         player.overwritePpdc(tag)
     }
 
+    override fun handleSynchronizePlayerMutes(packet: ClientboundSynchronizePlayerMutes) {
+        val player = commonPlayerManagerImpl.getPlayer(packet.playerUuid)
+
+        if (player == null) {
+            log.atWarning()
+                .log("Received mute update for unknown player (%s)", packet.playerUuid)
+            return
+        }
+
+        player.punishmentManager.updateMutes(packet.mutes)
+    }
+
     override fun handlePacket(packet: NettyPacket) {
         val listeners = NettyListenerRegistry.getListeners(packet.javaClass) ?: return
         if (listeners.isEmpty()) return

surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/netty/network/protocol/synchronizing/ClientSynchronizingPacketListener.kt

@@ -33,5 +33,7 @@ interface ClientSynchronizingPacketListener : ClientCommonPacketListener,
     fun handleSyncLargerPlayerPersistentDataContainerChunk(packet: ClientboundSyncLargePlayerPersistentDataContainerChunkPacket)
     fun handleSyncLargerPlayerPersistentDataContainerEnd(packet: ClientboundSyncLargePlayerPersistentDataContainerEndPacket)
 
+    fun handleSynchronizePlayerMutes(packet: ClientboundSynchronizePlayerMutes)
+
     fun handlePacket(packet: NettyPacket)
 }

surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/netty/network/protocol/synchronizing/ClientboundSynchronizePlayerMutes.kt

@@ -0,0 +1,37 @@
+package dev.slne.surf.cloud.core.common.netty.network.protocol.synchronizing
+
+import dev.slne.surf.cloud.api.common.meta.SurfNettyPacket
+import dev.slne.surf.cloud.api.common.netty.network.ConnectionProtocol
+import dev.slne.surf.cloud.api.common.netty.network.codec.ByteBufCodecs
+import dev.slne.surf.cloud.api.common.netty.network.codec.StreamCodec
+import dev.slne.surf.cloud.api.common.netty.network.protocol.PacketFlow
+import dev.slne.surf.cloud.api.common.netty.packet.NettyPacket
+import dev.slne.surf.cloud.api.common.netty.packet.PacketHandlerMode
+import dev.slne.surf.cloud.core.common.netty.network.InternalNettyPacket
+import dev.slne.surf.cloud.core.common.player.punishment.type.PunishmentMuteImpl
+import java.util.*
+
+@SurfNettyPacket(
+    "cloud:clientbound:synchronize_punishments/mutes",
+    PacketFlow.CLIENTBOUND,
+    ConnectionProtocol.SYNCHRONIZING,
+    handlerMode = PacketHandlerMode.NETTY
+)
+class ClientboundSynchronizePlayerMutes(
+    val playerUuid: UUID,
+    val mutes: MutableList<PunishmentMuteImpl>
+) : NettyPacket(), InternalNettyPacket<ClientSynchronizingPacketListener> {
+    companion object {
+        val STREAM_CODEC = StreamCodec.composite(
+            ByteBufCodecs.UUID_CODEC,
+            ClientboundSynchronizePlayerMutes::playerUuid,
+            PunishmentMuteImpl.STREAM_CODEC.apply(ByteBufCodecs.list()),
+            ClientboundSynchronizePlayerMutes::mutes,
+            ::ClientboundSynchronizePlayerMutes
+        )
+    }
+
+    override fun handle(listener: ClientSynchronizingPacketListener) {
+        listener.handleSynchronizePlayerMutes(this)
+    }
+}

surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/netty/network/protocol/synchronizing/SynchronizingProtocols.kt

@@ -32,6 +32,7 @@ object SynchronizingProtocols {
                 .addPacket(ClientboundSyncLargePlayerPersistentDataContainerStartPacket.STREAM_CODEC)
                 .addPacket(ClientboundSyncLargePlayerPersistentDataContainerEndPacket.STREAM_CODEC)
                 .addPacket(ClientboundSyncLargePlayerPersistentDataContainerChunkPacket.STREAM_CODEC)
+                .addPacket(ClientboundSynchronizePlayerMutes.STREAM_CODEC)
         }
 
     val CLIENTBOUND by lazy { CLIENTBOUND_TEMPLATE.bind(::SurfByteBuf) }

surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/player/punishment/CloudPlayerPunishmentManagerImpl.kt

@@ -9,15 +9,15 @@ import dev.slne.surf.cloud.api.common.player.punishment.type.ban.PunishmentBan
 import dev.slne.surf.cloud.api.common.player.punishment.type.kick.PunishmentKick
 import dev.slne.surf.cloud.api.common.player.punishment.type.mute.PunishmentMute
 import dev.slne.surf.cloud.api.common.player.punishment.type.warn.PunishmentWarn
-import dev.slne.surf.surfapi.core.api.util.emptyObjectList
-import dev.slne.surf.surfapi.core.api.util.toObjectList
 import dev.slne.surf.cloud.core.common.player.PunishmentManager
 import dev.slne.surf.cloud.core.common.player.punishment.type.PunishmentBanImpl
 import dev.slne.surf.cloud.core.common.player.punishment.type.PunishmentKickImpl
 import dev.slne.surf.cloud.core.common.player.punishment.type.PunishmentMuteImpl
 import dev.slne.surf.cloud.core.common.player.punishment.type.PunishmentWarnImpl
 import dev.slne.surf.cloud.core.common.util.bean
+import dev.slne.surf.surfapi.core.api.util.emptyObjectList
 import dev.slne.surf.surfapi.core.api.util.logger
+import dev.slne.surf.surfapi.core.api.util.toObjectList
 import it.unimi.dsi.fastutil.objects.ObjectList
 import org.jetbrains.annotations.Unmodifiable
 import java.util.*
@@ -66,6 +66,28 @@ class CloudPlayerPunishmentManagerImpl(private val playerUuid: UUID) :
         return (if (sort) mutes.sorted() else mutes).toObjectList()
     }
 
+    fun rawCachedMutes(): MutableList<PunishmentMuteImpl> {
+        return cachedMutes
+    }
+
+    fun updateMutes(updated: List<PunishmentMuteImpl>) {
+        if (!cachedMutesFetched) {
+            cachedMutes = CopyOnWriteArrayList(updated)
+            cachedMutesFetched = true
+            return
+        }
+
+        val iterator = cachedMutes.iterator()
+        while (iterator.hasNext()) {
+            val mute = iterator.next()
+            if (updated.any { it.punishmentId == mute.punishmentId }) {
+                iterator.remove()
+            }
+        }
+
+        cachedMutes.addAll(updated)
+    }
+
     @Suppress("UNCHECKED_CAST")
     suspend fun cacheMutes() {
         cachedMutes = CopyOnWriteArrayList(fetchMutes() as ObjectList<PunishmentMuteImpl>)

surf-cloud-standalone/src/main/kotlin/dev/slne/surf/cloud/standalone/netty/server/network/ServerSynchronizingPacketListenerImpl.kt

@@ -19,10 +19,7 @@ import dev.slne.surf.cloud.core.common.netty.registry.listener.NettyListenerRegi
 import dev.slne.surf.cloud.core.common.plugin.task.CloudSynchronizeTaskManager
 import dev.slne.surf.cloud.standalone.netty.server.NettyServerImpl
 import dev.slne.surf.cloud.standalone.netty.server.ServerClientImpl
-import dev.slne.surf.cloud.standalone.netty.server.network.config.SetVelocitySecretTask
-import dev.slne.surf.cloud.standalone.netty.server.network.config.SynchronizeRegistriesTask
-import dev.slne.surf.cloud.standalone.netty.server.network.config.SynchronizeServersTask
-import dev.slne.surf.cloud.standalone.netty.server.network.config.SynchronizeUserTask
+import dev.slne.surf.cloud.standalone.netty.server.network.config.*
 import dev.slne.surf.cloud.standalone.sync.SyncRegistryImpl
 import dev.slne.surf.surfapi.core.api.util.logger
 import kotlinx.coroutines.launch
@@ -59,6 +56,8 @@ class ServerSynchronizingPacketListenerImpl(
             SynchronizeServersTask.execute(client)
             SynchronizeRegistriesTask.execute(client)
             SynchronizeUserTask.execute(client)
+            SynchronizePlayerPunishmentManagers.execute(client)
+
             CloudSynchronizeTaskManager.executeTasks(client)
 
             state = State.WAIT_FOR_CLIENT

surf-cloud-standalone/src/main/kotlin/dev/slne/surf/cloud/standalone/netty/server/network/config/SynchronizePlayerPunishmentManagers.kt

@@ -0,0 +1,25 @@
+package dev.slne.surf.cloud.standalone.netty.server.network.config
+
+import dev.slne.surf.cloud.api.common.netty.NettyClient
+import dev.slne.surf.cloud.api.common.plugin.spring.task.CloudInitialSynchronizeTask
+import dev.slne.surf.cloud.core.common.netty.network.protocol.synchronizing.ClientboundSynchronizePlayerMutes
+import dev.slne.surf.cloud.standalone.player.StandaloneCloudPlayerImpl
+import dev.slne.surf.cloud.standalone.player.standalonePlayerManagerImpl
+
+object SynchronizePlayerPunishmentManagers : CloudInitialSynchronizeTask {
+    override suspend fun execute(client: NettyClient) {
+        val players = standalonePlayerManagerImpl.getRawOnlinePlayers()
+        synchronizeCachedMutes(client, players)
+    }
+
+    private fun synchronizeCachedMutes(
+        client: NettyClient,
+        players: List<StandaloneCloudPlayerImpl>
+    ) {
+        for (player in players) {
+            val mutes = player.punishmentManager.rawCachedMutes()
+            if (mutes.isEmpty()) continue
+            client.fireAndForget(ClientboundSynchronizePlayerMutes(player.uuid, mutes))
+        }
+    }
+}