feat: introduce persistent player data tracking and binary tag handling

- Added `TrackingPlayerPersistentDataContainerImpl` for player data tracking with patch-based updates.
- Implemented binary tag codecs (`BINARY_TAG_CODEC`, `BINARY_TAG_CODEC_COMPRESSED`) for NBT serialization.
- Integrated persistent data container updates with `ClientboundUpdatePlayerPersistentDataContainerPacket`.
- Enhanced persistent data handling in `StandaloneCloudPlayerImpl` with tracking and broadcast logic.
- Updated `PersistentPlayerDataContainerImpl` with utility methods for patch operations (`applyOps`, `getPatchOps`).
- Added error handling for failed data fetches in `onNetworkConnect`.
- Optimized collection codec constructors in `ByteBufCodecs` for size constraints and performance.

Author: twisti-dev

surf-cloud-api/surf-cloud-api-common/src/main/kotlin/dev/slne/surf/cloud/api/common/netty/network/codec/ByteBufCodecs.kt

@@ -5,8 +5,16 @@ import dev.slne.surf.cloud.api.common.netty.protocol.buffer.types.Utf8String
 import dev.slne.surf.cloud.api.common.util.ByIdMap
 import dev.slne.surf.cloud.api.common.util.createUnresolvedInetSocketAddress
 import io.netty.buffer.ByteBuf
+import io.netty.buffer.ByteBufInputStream
+import io.netty.buffer.ByteBufOutputStream
+import io.netty.handler.codec.DecoderException
+import io.netty.handler.codec.EncoderException
+import it.unimi.dsi.fastutil.objects.ObjectArrayList
 import net.kyori.adventure.key.Key
+import net.kyori.adventure.nbt.BinaryTag
 import net.kyori.adventure.nbt.BinaryTagIO
+import net.kyori.adventure.nbt.BinaryTagType
+import net.kyori.adventure.nbt.BinaryTagTypes
 import net.kyori.adventure.sound.Sound
 import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer
 import java.io.ByteArrayInputStream
@@ -21,10 +29,13 @@ import java.time.Instant
 import java.time.ZoneId
 import java.time.ZonedDateTime
 import java.util.*
+import kotlin.math.min
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.milliseconds
 
 object ByteBufCodecs {
+    const val MAX_INITIAL_COLLECTION_SIZE = 65536
+
     val BOOLEAN_CODEC = streamCodec(ByteBuf::writeBoolean, ByteBuf::readBoolean)
     val BYTE_CODEC = streamCodec({ buf, byte -> buf.writeByte(byte.toInt()) }, ByteBuf::readByte)
     val SHORT_CODEC =
@@ -138,6 +149,53 @@ object ByteBufCodecs {
         BigDecimal(unscaledValue, scale, MathContext(precision))
     }
 
+    private val TAG_TYPES = arrayOf(
+        BinaryTagTypes.END,
+        BinaryTagTypes.BYTE,
+        BinaryTagTypes.SHORT,
+        BinaryTagTypes.INT,
+        BinaryTagTypes.LONG,
+        BinaryTagTypes.FLOAT,
+        BinaryTagTypes.DOUBLE,
+        BinaryTagTypes.BYTE_ARRAY,
+        BinaryTagTypes.STRING,
+        BinaryTagTypes.LIST,
+        BinaryTagTypes.COMPOUND,
+        BinaryTagTypes.INT_ARRAY,
+        BinaryTagTypes.LONG_ARRAY,
+    )
+
+    fun getTagType(id: Int): BinaryTagType<*> {
+        return if (id >= 0 && id < TAG_TYPES.size) TAG_TYPES[id] else error("Unknown tag type id: $id")
+    }
+
+    val BINARY_TAG_CODEC: StreamCodec<ByteBuf, BinaryTag> = streamCodec({ buf, tag ->
+        val type = tag.type() as BinaryTagType<BinaryTag>
+        buf.writeByte(type.id().toInt())
+        ByteBufOutputStream(buf).use {
+            type.write(tag, it)
+        }
+    }, { bytes ->
+        val typeId = bytes.readByte().toInt()
+        val type = getTagType(typeId)
+        ByteBufInputStream(bytes).use {
+            type.read(it)
+        }
+    })
+
+    val BINARY_TAG_CODEC_COMPRESSED: StreamCodec<ByteBuf, BinaryTag> = streamCodec({ buf, tag ->
+        val type = tag.type() as BinaryTagType<BinaryTag>
+        buf.writeByte(type.id().toInt())
+        ByteBufOutputStream(buf).use {
+            type.write(tag, it)
+        }
+    }, { bytes ->
+        val typeId = bytes.readByte().toInt()
+        val type = getTagType(typeId)
+        ByteBufInputStream(bytes).use {
+            type.read(it)
+        }
+    })
 
     fun <E : Enum<E>> enumStreamCodec(clazz: Class<E>): StreamCodec<ByteBuf, E> =
         streamCodec(ByteBuf::writeEnum) { it.readEnum(clazz) }
@@ -155,4 +213,59 @@ object ByteBufCodecs {
             buf.writeVarInt(idGetter(value))
         }
     }
+
+    fun readCount(buffer: ByteBuf, maxSize: Int): Int {
+        val count = buffer.readVarInt()
+        if (count > maxSize) {
+            throw DecoderException("$count elements exceeded max size of: $maxSize")
+        } else {
+            return count
+        }
+    }
+
+    fun writeCount(buffer: ByteBuf, count: Int, maxSize: Int) {
+        if (count > maxSize) {
+            throw EncoderException("$count elements exceeded max size of: $maxSize")
+        } else {
+            buffer.writeVarInt(count)
+        }
+    }
+
+    fun <B : ByteBuf, V, C : MutableCollection<V>> collection(
+        factory: (Int) -> C,
+        codec: StreamCodec<in B, V>,
+        maxSize: Int = Int.MAX_VALUE
+    ): StreamCodec<B, C> = object : StreamCodec<B, C> {
+        override fun decode(buf: B): C {
+            val count = readCount(buf, maxSize)
+            val collection = factory(min(count, MAX_INITIAL_COLLECTION_SIZE))
+
+            repeat(count) {
+                collection.add(codec.decode(buf))
+            }
+
+            return collection
+        }
+
+        override fun encode(buf: B, value: C) {
+            writeCount(buf, value.size, maxSize)
+
+            for (element in value) {
+                codec.encode(buf, element)
+            }
+        }
+    }
+
+    fun <B : ByteBuf, V, C : MutableCollection<V>> collection(factory: (Int) -> C): CodecOperation<B, V, C> {
+        return CodecOperation { size -> collection(factory, size) }
+    }
+
+
+    fun <B : ByteBuf, V> list(): CodecOperation<B, V, MutableList<V>> {
+        return CodecOperation { size -> collection(::ObjectArrayList, size) }
+    }
+
+    fun <B : ByteBuf, V> list(maxSize: Int): CodecOperation<B, V, MutableList<V>> {
+        return CodecOperation { size -> collection(::ObjectArrayList, size, maxSize) }
+    }
 }

surf-cloud-api/surf-cloud-api-common/src/main/kotlin/dev/slne/surf/cloud/api/common/player/CloudPlayer.kt

@@ -4,6 +4,7 @@ import dev.slne.surf.bytebufserializer.Buf
 import dev.slne.surf.cloud.api.common.netty.network.codec.kotlinx.cloud.CloudPlayerSerializer
 import dev.slne.surf.cloud.api.common.netty.network.codec.streamCodec
 import dev.slne.surf.cloud.api.common.player.ppdc.PersistentPlayerDataContainer
+import dev.slne.surf.cloud.api.common.player.ppdc.PersistentPlayerDataContainerView
 import dev.slne.surf.cloud.api.common.player.teleport.TeleportCause
 import dev.slne.surf.cloud.api.common.player.teleport.TeleportFlag
 import dev.slne.surf.cloud.api.common.player.teleport.WorldLocation
@@ -28,7 +29,7 @@ import kotlin.time.Duration
  * it enables sending messages or components to the player.
  */
 @Serializable(with = CloudPlayerSerializer::class)
-interface CloudPlayer : Audience, OfflineCloudPlayer { // TODO: conversation but done correctly?
+interface CloudPlayer : Audience, OfflineCloudPlayer {
     val name: String
 
     override suspend fun latestIpAddress(): Inet4Address
@@ -54,6 +55,8 @@ interface CloudPlayer : Audience, OfflineCloudPlayer { // TODO: conversation but
     fun isAfk(): Boolean
     suspend fun currentSessionDuration(): Duration
 
+    val persistentData: PersistentPlayerDataContainerView
+
     /**
      * Performs modifications on the player's persistent data container.
      *

surf-cloud-core/surf-cloud-core-client/src/main/kotlin/dev/slne/surf/cloud/core/client/player/ClientCloudPlayerImpl.kt

@@ -23,14 +23,17 @@ import dev.slne.surf.cloud.core.common.netty.network.protocol.running.Serverboun
 import dev.slne.surf.cloud.core.common.netty.network.protocol.running.ServerboundRequestPlayerDataResponse.*
 import dev.slne.surf.cloud.core.common.player.CommonCloudPlayerImpl
 import dev.slne.surf.cloud.core.common.player.ppdc.PersistentPlayerDataContainerImpl
+import dev.slne.surf.cloud.core.common.player.ppdc.PersistentPlayerDataContainerViewImpl
 import dev.slne.surf.cloud.core.common.util.hasPermissionPlattform
 import dev.slne.surf.surfapi.core.api.messages.adventure.getPointer
+import dev.slne.surf.surfapi.core.api.nbt.FastCompoundBinaryTag
 import dev.slne.surf.surfapi.core.api.nbt.fast
 import net.kyori.adventure.audience.Audience
 import net.kyori.adventure.audience.MessageType
 import net.kyori.adventure.bossbar.BossBar
 import net.kyori.adventure.identity.Identity
 import net.kyori.adventure.inventory.Book
+import net.kyori.adventure.nbt.CompoundBinaryTag
 import net.kyori.adventure.resource.ResourcePackRequest
 import net.kyori.adventure.sound.Sound
 import net.kyori.adventure.sound.Sound.Emitter
@@ -64,6 +67,12 @@ abstract class ClientCloudPlayerImpl<PlatformPlayer : Audience>(
     override val connectedToProxy get() = proxyServerName != null
     override val connectedToServer get() = serverName != null
 
+    var ppdcData: FastCompoundBinaryTag = CompoundBinaryTag.empty().fast()
+    override val persistentData = object : PersistentPlayerDataContainerViewImpl() {
+        override fun toTagCompound() = ppdcData
+        override fun getTag(key: String) = ppdcData.get(key)
+    }
+
     /**
      * 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.

surf-cloud-core/surf-cloud-core-client/src/main/kotlin/dev/slne/surf/cloud/core/client/player/CommonClientCloudPlayerManagerImpl.kt

@@ -1,13 +1,22 @@
 package dev.slne.surf.cloud.core.client.player
 
+import dev.slne.surf.cloud.api.client.netty.packet.fireAndAwaitOrThrow
+import dev.slne.surf.cloud.api.common.player.task.PrePlayerJoinTask
+import dev.slne.surf.cloud.core.common.messages.MessageManager
+import dev.slne.surf.cloud.core.common.netty.network.protocol.running.ServerboundRequestPlayerPersistentDataContainer
 import dev.slne.surf.cloud.core.common.player.CloudPlayerManagerImpl
 import dev.slne.surf.cloud.core.common.player.CommonOfflineCloudPlayerImpl
 import dev.slne.surf.cloud.core.common.player.playerManagerImpl
+import dev.slne.surf.surfapi.core.api.nbt.fast
+import dev.slne.surf.surfapi.core.api.util.logger
 import net.kyori.adventure.audience.Audience
 import java.util.*
+import java.util.concurrent.TimeUnit
 
 abstract class CommonClientCloudPlayerManagerImpl<Platform : Audience, P : ClientCloudPlayerImpl<Platform>> :
     CloudPlayerManagerImpl<P>() {
+    private val log = logger()
+
     override suspend fun updateProxyServer(
         player: P,
         serverName: String
@@ -44,10 +53,32 @@ abstract class CommonClientCloudPlayerManagerImpl<Platform : Audience, P : Clien
         return player.serverName
     }
 
-    override fun getOfflinePlayer(uuid: UUID, createIfNotExists: Boolean): CommonOfflineCloudPlayerImpl {
+    override fun getOfflinePlayer(
+        uuid: UUID,
+        createIfNotExists: Boolean
+    ): CommonOfflineCloudPlayerImpl {
         return OfflineCloudPlayerImpl(uuid, createIfNotExists)
     }
 
+    override suspend fun onNetworkConnect(uuid: UUID, player: P) {
+        try {
+            val ppdcData = ServerboundRequestPlayerPersistentDataContainer(uuid)
+                .fireAndAwaitOrThrow()
+                .nbt
+
+            player.ppdcData = ppdcData.fast()
+        } catch (e: Exception) {
+            log.atWarning()
+                .withCause(e)
+                .atMostEvery(5, TimeUnit.SECONDS)
+                .log("Could not fetch persistent player data container for player $uuid, denying join")
+
+            throw PreJoinDenied(PrePlayerJoinTask.Result.DENIED(MessageManager.couldNotFetchPlayerData))
+        }
+
+        super.onNetworkConnect(uuid, player)
+    }
+
     abstract fun getAudience(uuid: UUID): Audience?
 }
 

surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/messages/MessageManager.kt

@@ -69,6 +69,19 @@ object MessageManager { // TODO: Add more messages
         )
     }
 
+    val couldNotFetchPlayerData = buildText {
+        CommonComponents.renderDisconnectMessage(
+            this,
+            "FEHLER BEIM LADEN DEINER SPIELERDATEN",
+            {
+                error("Beim Laden deiner Spielerdaten ist ein Fehler aufgetreten.")
+                appendNewline()
+                error("Bitte versuche es erneut.")
+            },
+            true
+        )
+    }
+
     fun formatZonedDateTime(time: ZonedDateTime?) = buildText {
         if (time == null) {
             variableValue("N/A")

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

@@ -0,0 +1,25 @@
+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.codec.ByteBufCodecs
+import dev.slne.surf.cloud.api.common.netty.network.codec.streamCodecComposite
+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.core.common.player.ppdc.network.PdcPatch
+import java.util.*
+
+@SurfNettyPacket("cloud:clientbound:player_pdc/update", PacketFlow.CLIENTBOUND)
+class ClientboundUpdatePlayerPersistentDataContainerPacket(
+    val uuid: UUID,
+    val patch: PdcPatch
+) : NettyPacket() {
+    companion object {
+        val STREAM_CODEC = streamCodecComposite(
+            ByteBufCodecs.UUID_CODEC,
+            ClientboundUpdatePlayerPersistentDataContainerPacket::uuid,
+            PdcPatch.STREAM_CODEC,
+            ClientboundUpdatePlayerPersistentDataContainerPacket::patch,
+            ::ClientboundUpdatePlayerPersistentDataContainerPacket
+        )
+    }
+}

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

@@ -300,7 +300,7 @@ abstract class CloudPlayerManagerImpl<P : CommonCloudPlayerImpl> : CloudPlayerMa
     open fun terminate() {}
 
 
-    private class PreJoinDenied(val result: PrePlayerJoinTask.Result) : RuntimeException() {
+    class PreJoinDenied(val result: PrePlayerJoinTask.Result) : RuntimeException() {
         companion object {
             @Serial
             private const val serialVersionUID: Long = -5043277924406776272L