packets: Add 1_21_6 module

libraries/packets/build.gradle.kts

@@ -21,6 +21,7 @@ dependencies {
     compileOnly("io.papermc.paper:paper-api:1.21.5-R0.1-SNAPSHOT")
 
     implementation(project(":libraries:packets:packets-api"))
+    implementation(project(":libraries:packets:implementations:1_21_6"))
     implementation(project(":libraries:packets:implementations:1_21_5"))
     implementation(project(":libraries:packets:implementations:1_21_4"))
     implementation(project(":libraries:packets:implementations:1_21_3"))

libraries/packets/implementations/1_21_6/build.gradle.kts

@@ -0,0 +1,25 @@
+plugins {
+    id("java-library")
+    id("io.papermc.paperweight.userdev")
+}
+
+paperweight.reobfArtifactConfiguration = io.papermc.paperweight.userdev.ReobfArtifactConfiguration.MOJANG_PRODUCTION
+
+dependencies {
+    paperweight.paperDevBundle("1.21.5-R0.1-SNAPSHOT")
+    compileOnly(project(":libraries:packets:packets-api"))
+
+    compileOnly("com.fancyinnovations:fancymc:25w20a")
+
+    testImplementation(project(":libraries:packets"))
+    testImplementation(project(":libraries:packets:packets-api"))
+    testImplementation("org.junit.jupiter:junit-jupiter-api:5.12.2")
+    testImplementation("org.junit.jupiter:junit-jupiter-engine:5.12.2")
+    testImplementation("org.junit.platform:junit-platform-console-standalone:1.12.2")
+}
+
+tasks {
+    test {
+        useJUnitPlatform()
+    }
+}

libraries/packets/implementations/1_21_6/src/main/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundAddEntityPacketImpl.java

@@ -0,0 +1,48 @@
+package de.oliver.fancysitula.versions.v1_21_6.packets;
+
+import de.oliver.fancysitula.api.entities.FS_RealPlayer;
+import de.oliver.fancysitula.api.packets.FS_ClientboundAddEntityPacket;
+import de.oliver.fancysitula.api.utils.AngelConverter;
+import de.oliver.fancysitula.versions.v1_21_6.utils.VanillaPlayerAdapter;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.network.protocol.game.ClientboundAddEntityPacket;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.phys.Vec3;
+import org.bukkit.craftbukkit.util.CraftNamespacedKey;
+import org.bukkit.entity.EntityType;
+
+import java.util.UUID;
+
+public class ClientboundAddEntityPacketImpl extends FS_ClientboundAddEntityPacket {
+
+    public ClientboundAddEntityPacketImpl(int entityId, UUID entityUUID, EntityType entityType, double x, double y, double z, float yaw, float pitch, float headYaw, int velocityX, int velocityY, int velocityZ, int data) {
+        super(entityId, entityUUID, entityType, x, y, z, yaw, pitch, headYaw, velocityX, velocityY, velocityZ, data);
+    }
+
+    @Override
+    public Object createPacket() {
+        net.minecraft.world.entity.EntityType<?> vanillaType = BuiltInRegistries.ENTITY_TYPE.getValue(CraftNamespacedKey.toMinecraft(entityType.getKey()));
+
+        return new ClientboundAddEntityPacket(
+                entityId,
+                entityUUID,
+                x,
+                y,
+                z,
+                AngelConverter.degreesToVanillaByte(pitch),
+                AngelConverter.degreesToVanillaByte(yaw),
+                vanillaType,
+                data,
+                new Vec3(velocityX, velocityY, velocityZ),
+                AngelConverter.degreesToVanillaByte(headYaw)
+        );
+    }
+
+    @Override
+    public void sendPacketTo(FS_RealPlayer player) {
+        ClientboundAddEntityPacket packet = (ClientboundAddEntityPacket) createPacket();
+
+        ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer());
+        vanillaPlayer.connection.send(packet);
+    }
+}

libraries/packets/implementations/1_21_6/src/main/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundCreateOrUpdateTeamPacketImpl.java

@@ -0,0 +1,128 @@
+package de.oliver.fancysitula.versions.v1_21_6.packets;
+
+import de.oliver.fancysitula.api.entities.FS_RealPlayer;
+import de.oliver.fancysitula.api.packets.FS_ClientboundCreateOrUpdateTeamPacket;
+import de.oliver.fancysitula.versions.v1_21_6.utils.VanillaPlayerAdapter;
+import io.papermc.paper.adventure.PaperAdventure;
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.protocol.game.ClientboundSetPlayerTeamPacket;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.scores.PlayerTeam;
+import net.minecraft.world.scores.Scoreboard;
+import net.minecraft.world.scores.Team;
+
+public class ClientboundCreateOrUpdateTeamPacketImpl extends FS_ClientboundCreateOrUpdateTeamPacket {
+
+    private static final Scoreboard SCOREBOARD = new Scoreboard();
+
+    public ClientboundCreateOrUpdateTeamPacketImpl(String teamName, CreateTeam createTeam) {
+        super(teamName, createTeam);
+    }
+
+    public ClientboundCreateOrUpdateTeamPacketImpl(String teamName, RemoveTeam removeTeam) {
+        super(teamName, removeTeam);
+    }
+
+    public ClientboundCreateOrUpdateTeamPacketImpl(String teamName, UpdateTeam updateTeam) {
+        super(teamName, updateTeam);
+    }
+
+    public ClientboundCreateOrUpdateTeamPacketImpl(String teamName, AddEntity addEntity) {
+        super(teamName, addEntity);
+    }
+
+    public ClientboundCreateOrUpdateTeamPacketImpl(String teamName, RemoveEntity removeEntity) {
+        super(teamName, removeEntity);
+    }
+
+    @Override
+    public Object createPacket() {
+        return switch (method) {
+            case CREATE_TEAM -> createCreateTeamPacket();
+            case REMOVE_TEAM -> createRemoveTeamPacket();
+            case UPDATE_TEAM -> createUpdateTeamPacket();
+            case ADD_ENTITY -> createAddEntityPacket();
+            case REMOVE_ENTITY -> createRemoveEntityPacket();
+        };
+    }
+
+    private Object createCreateTeamPacket() {
+        if (createTeam == null) {
+            return null;
+        }
+
+        PlayerTeam playerTeam = new PlayerTeam(SCOREBOARD, teamName);
+        playerTeam.setDisplayName(PaperAdventure.asVanilla(createTeam.getDisplayName()));
+        playerTeam.setAllowFriendlyFire(createTeam.isAllowFriendlyFire());
+        playerTeam.setSeeFriendlyInvisibles(createTeam.isCanSeeFriendlyInvisibles());
+        playerTeam.setNameTagVisibility(Team.Visibility.valueOf(createTeam.getNameTagVisibility().getName()));
+        playerTeam.setCollisionRule(PlayerTeam.CollisionRule.valueOf(createTeam.getCollisionRule().getName()));
+        playerTeam.setColor(ChatFormatting.getById(createTeam.getColor().getId()));
+        playerTeam.setPlayerPrefix(PaperAdventure.asVanilla(createTeam.getPrefix()));
+        playerTeam.setPlayerSuffix(PaperAdventure.asVanilla(createTeam.getSuffix()));
+        for (String entity : createTeam.getEntities()) {
+            playerTeam.getPlayers().add(entity);
+        }
+
+        return ClientboundSetPlayerTeamPacket.createAddOrModifyPacket(playerTeam, true);
+    }
+
+    private Object createRemoveTeamPacket() {
+        if (removeTeam == null) {
+            return null;
+        }
+
+        PlayerTeam playerTeam = new PlayerTeam(SCOREBOARD, teamName);
+        return ClientboundSetPlayerTeamPacket.createRemovePacket(playerTeam);
+    }
+
+    private Object createUpdateTeamPacket() {
+        if (updateTeam == null) {
+            return null;
+        }
+
+        PlayerTeam playerTeam = new PlayerTeam(SCOREBOARD, teamName);
+        playerTeam.setDisplayName(PaperAdventure.asVanilla(updateTeam.getDisplayName()));
+        playerTeam.setAllowFriendlyFire(updateTeam.isAllowFriendlyFire());
+        playerTeam.setSeeFriendlyInvisibles(updateTeam.isCanSeeFriendlyInvisibles());
+        playerTeam.setNameTagVisibility(Team.Visibility.valueOf(updateTeam.getNameTagVisibility().getName()));
+        playerTeam.setCollisionRule(PlayerTeam.CollisionRule.valueOf(updateTeam.getCollisionRule().getName()));
+        playerTeam.setColor(ChatFormatting.getById(updateTeam.getColor().getId()));
+        playerTeam.setPlayerPrefix(PaperAdventure.asVanilla(updateTeam.getPrefix()));
+        playerTeam.setPlayerSuffix(PaperAdventure.asVanilla(updateTeam.getSuffix()));
+
+        return ClientboundSetPlayerTeamPacket.createAddOrModifyPacket(playerTeam, true);
+    }
+
+    private Object createAddEntityPacket() {
+        if (addEntity == null) {
+            return null;
+        }
+
+        PlayerTeam playerTeam = new PlayerTeam(SCOREBOARD, teamName);
+        for (String entity : addEntity.getEntities()) {
+            playerTeam.getPlayers().add(entity);
+        }
+        return ClientboundSetPlayerTeamPacket.createMultiplePlayerPacket(playerTeam, addEntity.getEntities(), ClientboundSetPlayerTeamPacket.Action.ADD);
+    }
+
+    private Object createRemoveEntityPacket() {
+        if (removeEntity == null) {
+            return null;
+        }
+
+        PlayerTeam playerTeam = new PlayerTeam(SCOREBOARD, teamName);
+        for (String entity : removeEntity.getEntities()) {
+            playerTeam.getPlayers().add(entity);
+        }
+        return ClientboundSetPlayerTeamPacket.createMultiplePlayerPacket(playerTeam, removeEntity.getEntities(), ClientboundSetPlayerTeamPacket.Action.REMOVE);
+    }
+
+    @Override
+    protected void sendPacketTo(FS_RealPlayer player) {
+        ClientboundSetPlayerTeamPacket packet = (ClientboundSetPlayerTeamPacket) createPacket();
+
+        ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer());
+        vanillaPlayer.connection.send(packet);
+    }
+}

libraries/packets/implementations/1_21_6/src/main/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundPlayerInfoRemovePacketImpl.java

@@ -0,0 +1,30 @@
+package de.oliver.fancysitula.versions.v1_21_6.packets;
+
+import de.oliver.fancysitula.api.entities.FS_RealPlayer;
+import de.oliver.fancysitula.api.packets.FS_ClientboundPlayerInfoRemovePacket;
+import de.oliver.fancysitula.versions.v1_21_6.utils.VanillaPlayerAdapter;
+import net.minecraft.network.protocol.game.ClientboundPlayerInfoRemovePacket;
+import net.minecraft.server.level.ServerPlayer;
+
+import java.util.List;
+import java.util.UUID;
+
+public class ClientboundPlayerInfoRemovePacketImpl extends FS_ClientboundPlayerInfoRemovePacket {
+
+    public ClientboundPlayerInfoRemovePacketImpl(List<UUID> uuids) {
+        super(uuids);
+    }
+
+    @Override
+    public Object createPacket() {
+        return new ClientboundPlayerInfoRemovePacket(uuids);
+    }
+
+    @Override
+    public void sendPacketTo(FS_RealPlayer player) {
+        ClientboundPlayerInfoRemovePacket packet = (ClientboundPlayerInfoRemovePacket) createPacket();
+
+        ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer());
+        vanillaPlayer.connection.send(packet);
+    }
+}

libraries/packets/implementations/1_21_6/src/main/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundPlayerInfoUpdatePacketImpl.java

@@ -0,0 +1,54 @@
+package de.oliver.fancysitula.versions.v1_21_6.packets;
+
+import de.oliver.fancysitula.api.entities.FS_RealPlayer;
+import de.oliver.fancysitula.api.packets.FS_ClientboundPlayerInfoUpdatePacket;
+import de.oliver.fancysitula.versions.v1_21_6.utils.GameProfileImpl;
+import de.oliver.fancysitula.versions.v1_21_6.utils.VanillaPlayerAdapter;
+import io.papermc.paper.adventure.PaperAdventure;
+import net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.level.GameType;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+
+public class ClientboundPlayerInfoUpdatePacketImpl extends FS_ClientboundPlayerInfoUpdatePacket {
+
+    public ClientboundPlayerInfoUpdatePacketImpl(EnumSet<Action> actions, List<Entry> entries) {
+        super(actions, entries);
+    }
+
+    @Override
+    public Object createPacket() {
+        EnumSet<ClientboundPlayerInfoUpdatePacket.Action> vanillaActions = EnumSet.noneOf(ClientboundPlayerInfoUpdatePacket.Action.class);
+        for (FS_ClientboundPlayerInfoUpdatePacket.Action action : actions) {
+            vanillaActions.add(ClientboundPlayerInfoUpdatePacket.Action.valueOf(action.name()));
+        }
+
+        List<ClientboundPlayerInfoUpdatePacket.Entry> entries = new ArrayList<>();
+        for (Entry entry : this.entries) {
+            entries.add(new ClientboundPlayerInfoUpdatePacket.Entry(
+                    entry.uuid(),
+                    GameProfileImpl.asVanilla(entry.profile()),
+                    entry.listed(),
+                    entry.latency(),
+                    GameType.byId(entry.gameMode().getId()),
+                    PaperAdventure.asVanilla(entry.displayName()),
+                    true,
+                    -1,
+                    null // TODO: Add ChatSession support
+            ));
+        }
+
+        return new ClientboundPlayerInfoUpdatePacket(vanillaActions, entries);
+    }
+
+    @Override
+    public void sendPacketTo(FS_RealPlayer player) {
+        ClientboundPlayerInfoUpdatePacket packet = (ClientboundPlayerInfoUpdatePacket) createPacket();
+
+        ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer());
+        vanillaPlayer.connection.send(packet);
+    }
+}

libraries/packets/implementations/1_21_6/src/main/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundRemoveEntitiesPacketImpl.java

@@ -0,0 +1,37 @@
+package de.oliver.fancysitula.versions.v1_21_6.packets;
+
+import de.oliver.fancysitula.api.entities.FS_RealPlayer;
+import de.oliver.fancysitula.api.packets.FS_ClientboundRemoveEntitiesPacket;
+import de.oliver.fancysitula.versions.v1_21_6.utils.VanillaPlayerAdapter;
+import net.minecraft.network.protocol.game.ClientboundRemoveEntitiesPacket;
+import net.minecraft.server.level.ServerPlayer;
+
+import java.util.List;
+
+public class ClientboundRemoveEntitiesPacketImpl extends FS_ClientboundRemoveEntitiesPacket {
+
+    /**
+     * @param entityIds IDs of the entities to remove
+     */
+    public ClientboundRemoveEntitiesPacketImpl(List<Integer> entityIds) {
+        super(entityIds);
+    }
+
+    @Override
+    public Object createPacket() {
+        int[] ids = new int[this.entityIds.size()];
+        for (int i = 0; i < this.entityIds.size(); i++) {
+            ids[i] = this.entityIds.get(i);
+        }
+
+        return new ClientboundRemoveEntitiesPacket(ids);
+    }
+
+    @Override
+    public void sendPacketTo(FS_RealPlayer player) {
+        ClientboundRemoveEntitiesPacket packet = (ClientboundRemoveEntitiesPacket) createPacket();
+
+        ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer());
+        vanillaPlayer.connection.send(packet);
+    }
+}

libraries/packets/implementations/1_21_6/src/main/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundRotateHeadPacketImpl.java

@@ -0,0 +1,38 @@
+package de.oliver.fancysitula.versions.v1_21_6.packets;
+
+import de.oliver.fancysitula.api.entities.FS_RealPlayer;
+import de.oliver.fancysitula.api.packets.FS_ClientboundRotateHeadPacket;
+import de.oliver.fancysitula.api.utils.AngelConverter;
+import de.oliver.fancysitula.api.utils.reflections.ReflectionUtils;
+import de.oliver.fancysitula.versions.v1_21_6.utils.VanillaPlayerAdapter;
+import net.minecraft.network.protocol.game.ClientboundRotateHeadPacket;
+import net.minecraft.server.level.ServerPlayer;
+
+public class ClientboundRotateHeadPacketImpl extends FS_ClientboundRotateHeadPacket {
+
+    public ClientboundRotateHeadPacketImpl(int entityId, float headYaw) {
+        super(entityId, headYaw);
+    }
+
+    @Override
+    public Object createPacket() {
+        ClientboundRotateHeadPacket packet = null;
+
+        try {
+            packet = ReflectionUtils.createUnsafeInstance(ClientboundRotateHeadPacket.class);
+            ReflectionUtils.setFinalField(packet, "entityId", entityId);
+            ReflectionUtils.setFinalField(packet, "yHeadRot", AngelConverter.degreesToVanillaByte(headYaw));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return packet;
+    }
+
+    @Override
+    public void sendPacketTo(FS_RealPlayer player) {
+        ClientboundRotateHeadPacket packet = (ClientboundRotateHeadPacket) createPacket();
+
+        ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer());
+        vanillaPlayer.connection.send(packet);
+    }
+}

libraries/packets/implementations/1_21_6/src/main/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundSetEntityDataPacketImpl.java

@@ -0,0 +1,67 @@
+package de.oliver.fancysitula.versions.v1_21_6.packets;
+
+import de.oliver.fancysitula.api.entities.FS_RealPlayer;
+import de.oliver.fancysitula.api.packets.FS_ClientboundSetEntityDataPacket;
+import de.oliver.fancysitula.api.utils.reflections.ReflectionUtils;
+import de.oliver.fancysitula.versions.v1_21_6.utils.VanillaPlayerAdapter;
+import io.papermc.paper.adventure.PaperAdventure;
+import net.kyori.adventure.text.Component;
+import net.minecraft.network.protocol.game.ClientboundSetEntityDataPacket;
+import net.minecraft.network.syncher.SynchedEntityData;
+import net.minecraft.server.level.ServerPlayer;
+import org.bukkit.block.BlockState;
+import org.bukkit.craftbukkit.block.CraftBlockState;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ClientboundSetEntityDataPacketImpl extends FS_ClientboundSetEntityDataPacket {
+
+    public ClientboundSetEntityDataPacketImpl(int entityId, List<EntityData> entityData) {
+        super(entityId, entityData);
+    }
+
+    @Override
+    public Object createPacket() {
+        List<SynchedEntityData.DataValue<?>> dataValues = new ArrayList<>();
+        for (EntityData data : entityData) {
+            try {
+                Class<?> entityClass = Class.forName(data.getAccessor().entityClassName());
+                net.minecraft.network.syncher.EntityDataAccessor<Object> accessor = ReflectionUtils.getStaticField(entityClass, data.getAccessor().accessorFieldName());
+
+                Object vanillaValue = data.getValue();
+
+                if (data.getValue() == null) {
+                    continue;
+                }
+
+                if (data.getValue() instanceof Component c) {
+                    vanillaValue = PaperAdventure.asVanilla(c);
+                }
+
+                if (data.getValue() instanceof ItemStack i) {
+                    vanillaValue = net.minecraft.world.item.ItemStack.fromBukkitCopy(i);
+                }
+
+                if (data.getValue() instanceof BlockState b) {
+                    vanillaValue = ((CraftBlockState) b).getHandle();
+                }
+
+                dataValues.add(SynchedEntityData.DataValue.create(accessor, vanillaValue));
+            } catch (ClassNotFoundException | NoSuchFieldException | IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        }
+
+        return new ClientboundSetEntityDataPacket(entityId, dataValues);
+    }
+
+    @Override
+    public void sendPacketTo(FS_RealPlayer player) {
+        ClientboundSetEntityDataPacket packet = (ClientboundSetEntityDataPacket) createPacket();
+
+        ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer());
+        vanillaPlayer.connection.send(packet);
+    }
+}

libraries/packets/implementations/1_21_6/src/main/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundSetEquipmentPacketImpl.java

@@ -0,0 +1,45 @@
+package de.oliver.fancysitula.versions.v1_21_6.packets;
+
+import com.mojang.datafixers.util.Pair;
+import de.oliver.fancysitula.api.entities.FS_RealPlayer;
+import de.oliver.fancysitula.api.packets.FS_ClientboundSetEquipmentPacket;
+import de.oliver.fancysitula.api.utils.FS_EquipmentSlot;
+import de.oliver.fancysitula.versions.v1_21_6.utils.VanillaPlayerAdapter;
+import net.minecraft.network.protocol.game.ClientboundSetEquipmentPacket;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.EquipmentSlot;
+import org.bukkit.craftbukkit.inventory.CraftItemStack;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class ClientboundSetEquipmentPacketImpl extends FS_ClientboundSetEquipmentPacket {
+
+    public ClientboundSetEquipmentPacketImpl(int entityId, Map<FS_EquipmentSlot, ItemStack> equipment) {
+        super(entityId, equipment);
+    }
+
+    @Override
+    public Object createPacket() {
+        List<Pair<net.minecraft.world.entity.EquipmentSlot, net.minecraft.world.item.ItemStack>> slots = new ArrayList<>();
+
+        for (Map.Entry<FS_EquipmentSlot, ItemStack> entry : equipment.entrySet()) {
+            EquipmentSlot equipmentSlot = net.minecraft.world.entity.EquipmentSlot.byName(entry.getKey().name().toLowerCase());
+            net.minecraft.world.item.ItemStack itemStack = CraftItemStack.asNMSCopy(entry.getValue());
+
+            slots.add(Pair.of(equipmentSlot, itemStack));
+        }
+
+        return new ClientboundSetEquipmentPacket(entityId, slots);
+    }
+
+    @Override
+    public void sendPacketTo(FS_RealPlayer player) {
+        ClientboundSetEquipmentPacket packet = (ClientboundSetEquipmentPacket) createPacket();
+
+        ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer());
+        vanillaPlayer.connection.send(packet);
+    }
+}

libraries/packets/implementations/1_21_6/src/main/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundSetPassengersPacketImpl.java

@@ -0,0 +1,45 @@
+package de.oliver.fancysitula.versions.v1_21_6.packets;
+
+import de.oliver.fancysitula.api.entities.FS_RealPlayer;
+import de.oliver.fancysitula.api.packets.FS_ClientboundSetPassengersPacket;
+import de.oliver.fancysitula.api.utils.reflections.ReflectionUtils;
+import de.oliver.fancysitula.versions.v1_21_6.utils.VanillaPlayerAdapter;
+import net.minecraft.network.protocol.game.ClientboundSetPassengersPacket;
+import net.minecraft.server.level.ServerPlayer;
+
+import java.util.List;
+
+public class ClientboundSetPassengersPacketImpl extends FS_ClientboundSetPassengersPacket {
+
+    public ClientboundSetPassengersPacketImpl(int entityId, List<Integer> passengers) {
+        super(entityId, passengers);
+    }
+
+
+    @Override
+    public Object createPacket() {
+        int[] passengers = new int[this.passengers.size()];
+        for (int i = 0; i < this.passengers.size(); i++) {
+            passengers[i] = this.passengers.get(i);
+        }
+
+        try {
+            ClientboundSetPassengersPacket packet = ReflectionUtils.createUnsafeInstance(ClientboundSetPassengersPacket.class);
+            ReflectionUtils.setFinalField(packet, "vehicle", entityId);
+            ReflectionUtils.setFinalField(packet, "passengers", passengers);
+            return packet;
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    @Override
+    public void sendPacketTo(FS_RealPlayer player) {
+        ClientboundSetPassengersPacket packet = (ClientboundSetPassengersPacket) createPacket();
+
+        ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer());
+        vanillaPlayer.connection.send(packet);
+    }
+}

libraries/packets/implementations/1_21_6/src/main/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundTeleportEntityPacketImpl.java

@@ -0,0 +1,43 @@
+package de.oliver.fancysitula.versions.v1_21_6.packets;
+
+import de.oliver.fancysitula.api.entities.FS_RealPlayer;
+import de.oliver.fancysitula.api.packets.FS_ClientboundTeleportEntityPacket;
+import de.oliver.fancysitula.versions.v1_21_6.utils.VanillaPlayerAdapter;
+import net.minecraft.network.protocol.game.ClientboundTeleportEntityPacket;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.PositionMoveRotation;
+import net.minecraft.world.phys.Vec3;
+
+import java.util.Set;
+
+public class ClientboundTeleportEntityPacketImpl extends FS_ClientboundTeleportEntityPacket {
+
+    public ClientboundTeleportEntityPacketImpl(int entityId, double x, double y, double z, float yaw, float pitch, boolean onGround) {
+        super(entityId, x, y, z, yaw, pitch, onGround);
+    }
+
+    @Override
+    public Object createPacket() {
+        ClientboundTeleportEntityPacket packet = new ClientboundTeleportEntityPacket(
+                entityId,
+                new PositionMoveRotation(
+                        new Vec3(x, y, z),
+                        Vec3.ZERO,
+                        yaw,
+                        pitch
+                ),
+                Set.of(),
+                onGround
+        );
+
+        return packet;
+    }
+
+    @Override
+    public void sendPacketTo(FS_RealPlayer player) {
+        ClientboundTeleportEntityPacket packet = (ClientboundTeleportEntityPacket) createPacket();
+
+        ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer());
+        vanillaPlayer.connection.send(packet);
+    }
+}

libraries/packets/implementations/1_21_6/src/main/java/de/oliver/fancysitula/versions/v1_21_6/utils/GameProfileImpl.java

@@ -0,0 +1,33 @@
+package de.oliver.fancysitula.versions.v1_21_6.utils;
+
+import com.mojang.authlib.GameProfile;
+import de.oliver.fancysitula.api.utils.FS_GameProfile;
+
+import java.util.Map;
+
+public class GameProfileImpl {
+
+    public static GameProfile asVanilla(FS_GameProfile gameProfile) {
+        GameProfile gf = new GameProfile(gameProfile.getUUID(), gameProfile.getName());
+
+        for (Map.Entry<String, FS_GameProfile.Property> entry : gameProfile.getProperties().entrySet()) {
+            FS_GameProfile.Property property = entry.getValue();
+
+            gf.getProperties().put(entry.getKey(), new com.mojang.authlib.properties.Property(property.name(), property.value(), property.signature()));
+        }
+
+        return gf;
+    }
+
+    public static FS_GameProfile fromVanilla(GameProfile gameProfile) {
+        FS_GameProfile fsGameProfile = new FS_GameProfile(gameProfile.getId(), gameProfile.getName());
+
+        for (Map.Entry<String, com.mojang.authlib.properties.Property> entry : gameProfile.getProperties().entries()) {
+            com.mojang.authlib.properties.Property property = entry.getValue();
+
+            fsGameProfile.getProperties().put(entry.getKey(), new FS_GameProfile.Property(property.name(), property.value(), property.signature()));
+        }
+
+        return fsGameProfile;
+    }
+}

libraries/packets/implementations/1_21_6/src/main/java/de/oliver/fancysitula/versions/v1_21_6/utils/VanillaPlayerAdapter.java

@@ -0,0 +1,12 @@
+package de.oliver.fancysitula.versions.v1_21_6.utils;
+
+import net.minecraft.server.level.ServerPlayer;
+import org.bukkit.craftbukkit.entity.CraftPlayer;
+import org.bukkit.entity.Player;
+
+public class VanillaPlayerAdapter {
+
+    public static ServerPlayer asVanilla(Player p) {
+        return ((CraftPlayer) p).getHandle();
+    }
+}

libraries/packets/implementations/1_21_6/src/test/java/de/oliver/fancysitula/versions/v1_21_4/packets/ClientboundAddEntityPacketImplTest.java

@@ -0,0 +1,65 @@
+package de.oliver.fancysitula.versions.v1_21_4.packets;
+
+import de.oliver.fancysitula.api.utils.AngelConverter;
+import de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundAddEntityPacketImpl;
+import net.minecraft.network.protocol.game.ClientboundAddEntityPacket;
+import org.bukkit.entity.EntityType;
+
+import java.util.UUID;
+
+class ClientboundAddEntityPacketImplTest {
+
+    //TODO: Fix this test (registry problems)
+    //    @Test
+    void createPacket() {
+        int entityId = 10000;
+        UUID entityUUID = UUID.randomUUID();
+        EntityType entityType = EntityType.PIG;
+
+        double x = 5;
+        double y = 57;
+        double z = 203;
+
+        float yaw = 142;
+        float pitch = 247;
+        float headYaw = 90;
+
+        int velocityX = 0;
+        int velocityY = 0;
+        int velocityZ = 0;
+
+        int data = 0;
+
+        ClientboundAddEntityPacketImpl packet = new ClientboundAddEntityPacketImpl(
+                entityId,
+                entityUUID,
+                entityType,
+                x,
+                y,
+                z,
+                yaw,
+                pitch,
+                headYaw,
+                velocityX,
+                velocityY,
+                velocityZ,
+                data
+        );
+
+        ClientboundAddEntityPacket createdPacket = (ClientboundAddEntityPacket) packet.createPacket();
+
+        assert createdPacket.getId() == entityId;
+        assert createdPacket.getUUID().equals(entityUUID);
+        assert createdPacket.getType().getDescriptionId().equals(entityType.getKey().getKey());
+        assert createdPacket.getX() == x;
+        assert createdPacket.getY() == y;
+        assert createdPacket.getZ() == z;
+        assert createdPacket.getYRot() == AngelConverter.degreesToVanillaByte(yaw);
+        assert createdPacket.getXRot() == AngelConverter.degreesToVanillaByte(pitch);
+        assert createdPacket.getYHeadRot() == AngelConverter.degreesToVanillaByte(headYaw);
+        assert createdPacket.getXa() == velocityX;
+        assert createdPacket.getYa() == velocityY;
+        assert createdPacket.getZa() == velocityZ;
+        assert createdPacket.getData() == data;
+    }
+}

libraries/packets/implementations/1_21_6/src/test/java/de/oliver/fancysitula/versions/v1_21_4/packets/ClientboundPlayerInfoRemovePacketImplTest.java

@@ -0,0 +1,23 @@
+package de.oliver.fancysitula.versions.v1_21_4.packets;
+
+import de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundPlayerInfoRemovePacketImpl;
+import net.minecraft.network.protocol.game.ClientboundPlayerInfoRemovePacket;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.UUID;
+
+class ClientboundPlayerInfoRemovePacketImplTest {
+
+    @Test
+    void createPacket() {
+        List<UUID> uuids = List.of(UUID.randomUUID(), UUID.randomUUID());
+
+        ClientboundPlayerInfoRemovePacketImpl packet = new ClientboundPlayerInfoRemovePacketImpl(uuids);
+        ClientboundPlayerInfoRemovePacket vanillaPacket = (ClientboundPlayerInfoRemovePacket) packet.createPacket();
+
+        for (UUID uuid : uuids) {
+            assert vanillaPacket.profileIds().contains(uuid);
+        }
+    }
+}

libraries/packets/implementations/1_21_6/src/test/java/de/oliver/fancysitula/versions/v1_21_4/packets/ClientboundPlayerInfoUpdatePacketImplTest.java

@@ -0,0 +1,62 @@
+package de.oliver.fancysitula.versions.v1_21_4.packets;
+
+import de.oliver.fancysitula.api.packets.FS_ClientboundPlayerInfoUpdatePacket;
+import de.oliver.fancysitula.api.utils.FS_GameProfile;
+import de.oliver.fancysitula.api.utils.FS_GameType;
+import de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundPlayerInfoUpdatePacketImpl;
+import net.kyori.adventure.text.Component;
+import net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.UUID;
+
+class ClientboundPlayerInfoUpdatePacketImplTest {
+
+    @Test
+    void createPacket() {
+        // Setup packet
+        EnumSet<FS_ClientboundPlayerInfoUpdatePacket.Action> actions = EnumSet.noneOf(FS_ClientboundPlayerInfoUpdatePacket.Action.class);
+        actions.add(FS_ClientboundPlayerInfoUpdatePacket.Action.ADD_PLAYER);
+        actions.add(FS_ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME);
+        actions.add(FS_ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LISTED);
+
+        FS_GameProfile gameProfile = new FS_GameProfile(UUID.randomUUID(), "Test name");
+        boolean listed = true;
+        int latency = 42;
+        FS_GameType gameMode = FS_GameType.SURVIVAL;
+        Component displayName = Component.text("Test displayname");
+
+        List<FS_ClientboundPlayerInfoUpdatePacket.Entry> entries = new ArrayList<>();
+        entries.add(new FS_ClientboundPlayerInfoUpdatePacket.Entry(
+                gameProfile.getUUID(),
+                gameProfile,
+                listed,
+                latency,
+                gameMode,
+                displayName
+        ));
+
+        ClientboundPlayerInfoUpdatePacketImpl packet = new ClientboundPlayerInfoUpdatePacketImpl(actions, entries);
+
+        ClientboundPlayerInfoUpdatePacket createdPacket = (ClientboundPlayerInfoUpdatePacket) packet.createPacket();
+
+        assert createdPacket.entries().size() == 1;
+        assert createdPacket.actions().size() == 3;
+
+        // check entry
+        ClientboundPlayerInfoUpdatePacket.Entry entry = createdPacket.entries().getFirst();
+        assert entry.profile().getId().equals(gameProfile.getUUID());
+        assert entry.profile().getName().equals(gameProfile.getName());
+        assert entry.listed() == listed;
+        assert entry.latency() == latency;
+        assert entry.gameMode().getId() == gameMode.getId();
+
+        // check actions
+        assert createdPacket.actions().contains(ClientboundPlayerInfoUpdatePacket.Action.ADD_PLAYER);
+        assert createdPacket.actions().contains(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME);
+        assert createdPacket.actions().contains(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LISTED);
+    }
+}

libraries/packets/implementations/1_21_6/src/test/java/de/oliver/fancysitula/versions/v1_21_4/packets/ClientboundRemoveEntitiesPacketImplTest.java

@@ -0,0 +1,21 @@
+package de.oliver.fancysitula.versions.v1_21_4.packets;
+
+import de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundRemoveEntitiesPacketImpl;
+import net.minecraft.network.protocol.game.ClientboundRemoveEntitiesPacket;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+class ClientboundRemoveEntitiesPacketImplTest {
+
+    @Test
+    void createPacket() {
+        List<Integer> entityIds = List.of(95, 120, 154, 187);
+
+        ClientboundRemoveEntitiesPacketImpl packet = new ClientboundRemoveEntitiesPacketImpl(entityIds);
+        ClientboundRemoveEntitiesPacket createdPacket = (ClientboundRemoveEntitiesPacket) packet.createPacket();
+
+        assert createdPacket.getEntityIds().size() == entityIds.size();
+        assert createdPacket.getEntityIds().containsAll(entityIds);
+    }
+}

libraries/packets/implementations/1_21_6/src/test/java/de/oliver/fancysitula/versions/v1_21_4/packets/ClientboundRotateHeadPacketImplTest.java

@@ -0,0 +1,21 @@
+package de.oliver.fancysitula.versions.v1_21_4.packets;
+
+import de.oliver.fancysitula.api.utils.reflections.ReflectionUtils;
+import de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundRotateHeadPacketImpl;
+import net.minecraft.network.protocol.game.ClientboundRotateHeadPacket;
+import org.junit.jupiter.api.Test;
+
+class ClientboundRotateHeadPacketImplTest {
+
+    @Test
+    void createPacket() throws Exception {
+        int entityId = 184;
+        float headYaw = 45;
+
+        ClientboundRotateHeadPacketImpl packet = new ClientboundRotateHeadPacketImpl(entityId, (byte) headYaw);
+        ClientboundRotateHeadPacket createdPacket = (ClientboundRotateHeadPacket) packet.createPacket();
+
+        assert ReflectionUtils.getField(createdPacket, "entityId").equals(entityId);
+        assert createdPacket.getYHeadRot() == headYaw;
+    }
+}

libraries/packets/implementations/1_21_6/src/test/java/de/oliver/fancysitula/versions/v1_21_4/packets/ClientboundSetEntityDataPacketImplTest.java

@@ -0,0 +1,29 @@
+package de.oliver.fancysitula.versions.v1_21_4.packets;
+
+import de.oliver.fancysitula.api.packets.FS_ClientboundSetEntityDataPacket;
+import de.oliver.fancysitula.api.utils.entityData.FS_TextDisplayData;
+import de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundSetEntityDataPacketImpl;
+import net.minecraft.network.protocol.game.ClientboundSetEntityDataPacket;
+
+import java.util.List;
+
+class ClientboundSetEntityDataPacketImplTest {
+
+    //TODO: Fix this test (using registry)
+//    @Test
+    void createPacket() {
+        int entityId = 712;
+        List<FS_ClientboundSetEntityDataPacket.EntityData> entityData = List.of(
+                new FS_ClientboundSetEntityDataPacket.EntityData(
+                        FS_TextDisplayData.TEXT,
+                        "Hello, World!"
+                )
+        );
+
+        ClientboundSetEntityDataPacketImpl packet = new ClientboundSetEntityDataPacketImpl(entityId, entityData);
+        ClientboundSetEntityDataPacket createdPacket = (ClientboundSetEntityDataPacket) packet.createPacket();
+
+        assert createdPacket.id() == entityId;
+        assert createdPacket.packedItems().size() == 1;
+    }
+}

libraries/packets/implementations/1_21_6/src/test/java/de/oliver/fancysitula/versions/v1_21_4/packets/ClientboundSetEquipmentPacketImplTest.java

@@ -0,0 +1,29 @@
+package de.oliver.fancysitula.versions.v1_21_4.packets;
+
+import de.oliver.fancysitula.api.utils.FS_EquipmentSlot;
+import de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundSetEquipmentPacketImpl;
+import net.minecraft.network.protocol.game.ClientboundSetEquipmentPacket;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.Map;
+
+class ClientboundSetEquipmentPacketImplTest {
+
+    //TODO: Fix this test (registry problems)
+    //    @Test
+    void createPacket() {
+        // Setup packet
+        Map<FS_EquipmentSlot, ItemStack> equipment = Map.of(
+                FS_EquipmentSlot.MAINHAND, new ItemStack(Material.DIAMOND_SWORD),
+                FS_EquipmentSlot.OFFHAND, new ItemStack(Material.SHIELD),
+                FS_EquipmentSlot.HEAD, new ItemStack(Material.DIAMOND_HELMET)
+        );
+
+        ClientboundSetEquipmentPacketImpl packet = new ClientboundSetEquipmentPacketImpl(42, equipment);
+        ClientboundSetEquipmentPacket createdPacket = (ClientboundSetEquipmentPacket) packet.createPacket();
+
+        assert createdPacket.getEntity() == 42;
+        assert createdPacket.getSlots().size() == 3;
+    }
+}

libraries/packets/implementations/1_21_6/src/test/java/de/oliver/fancysitula/versions/v1_21_4/packets/ClientboundSetPassengersPacketImplTest.java

@@ -0,0 +1,29 @@
+package de.oliver.fancysitula.versions.v1_21_4.packets;
+
+import de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundSetPassengersPacketImpl;
+import net.minecraft.network.protocol.game.ClientboundSetPassengersPacket;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ClientboundSetPassengersPacketImplTest {
+
+    @Test
+    void createPacket() {
+        // Setup packet
+        int vehicleID = 712;
+        List<Integer> passengers = new ArrayList<>();
+        passengers.add(571);
+        passengers.add(572);
+
+        ClientboundSetPassengersPacketImpl packet = new ClientboundSetPassengersPacketImpl(vehicleID, passengers);
+        ClientboundSetPassengersPacket createdPacket = (ClientboundSetPassengersPacket) packet.createPacket();
+
+        // Check packet
+        assert createdPacket.getVehicle() == vehicleID;
+        assert createdPacket.getPassengers().length == 2;
+        assert createdPacket.getPassengers()[0] == 571;
+        assert createdPacket.getPassengers()[1] == 572;
+    }
+}

libraries/packets/implementations/1_21_6/src/test/java/de/oliver/fancysitula/versions/v1_21_4/packets/ClientboundTeleportEntityPacketImplTest.java

@@ -0,0 +1,31 @@
+package de.oliver.fancysitula.versions.v1_21_4.packets;
+
+import de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundTeleportEntityPacketImpl;
+import net.minecraft.network.protocol.game.ClientboundTeleportEntityPacket;
+import org.junit.jupiter.api.Test;
+
+class ClientboundTeleportEntityPacketImplTest {
+
+    @Test
+    void createPacket() {
+        int entityId = 4313;
+        double x = 15.0;
+        double y = 57.0;
+        double z = -27.0;
+        float yaw = 90.0f;
+        float pitch = 45.0f;
+        boolean onGround = true;
+
+        ClientboundTeleportEntityPacketImpl packet = new ClientboundTeleportEntityPacketImpl(entityId, x, y, z, yaw, pitch, onGround);
+        ClientboundTeleportEntityPacket createdPacket = (ClientboundTeleportEntityPacket) packet.createPacket();
+
+        assert createdPacket != null;
+        assert createdPacket.id() == entityId;
+        assert createdPacket.change().position().x == x;
+        assert createdPacket.change().position().y == y;
+        assert createdPacket.change().position().z == z;
+        assert createdPacket.change().xRot() == pitch;
+        assert createdPacket.change().yRot() == yaw;
+        assert createdPacket.onGround() == onGround;
+    }
+}

libraries/packets/packets-api/src/main/java/de/oliver/fancysitula/api/utils/ServerVersion.java

@@ -7,6 +7,7 @@ import java.util.List;
 
 public enum ServerVersion {
 
+    v1_21_6("1.21.6", 771),
     v1_21_5("1.21.5", 770),
     v1_21_4("1.21.4", 769),
     v1_21_3("1.21.3", 768),

settings.gradle.kts

@@ -45,6 +45,7 @@ include(":libraries:packets:implementations:1_21_1")
 include(":libraries:packets:implementations:1_21_3")
 include(":libraries:packets:implementations:1_21_4")
 include(":libraries:packets:implementations:1_21_5")
+include(":libraries:packets:implementations:1_21_6")
 
 
 include(":tools:deployment")