disguise api

and generate maps to allow entity metadata syncher validation

gradle.properties

@@ -8,3 +8,4 @@ updatingMinecraft=false
 org.gradle.caching=true
 org.gradle.parallel=true
 org.gradle.vfs.watch=false
+org.gradle.jvmargs=-Xmx4096m

paper-server-generator.settings.gradle.kts

@@ -0,0 +1,2 @@
+// Uncomment to enable the 'paper-server-generator' project
+// include(":paper-server-generator")

paper-server-generator/build.gradle.kts

@@ -0,0 +1,35 @@
+import io.papermc.paperweight.PaperweightSourceGeneratorHelper
+import io.papermc.paperweight.extension.PaperweightSourceGeneratorExt
+
+plugins {
+    java
+}
+
+plugins.apply(PaperweightSourceGeneratorHelper::class)
+
+extensions.configure(PaperweightSourceGeneratorExt::class) {
+    atFile.set(projectDir.toPath().resolve("wideners.at").toFile())
+}
+
+dependencies {
+    implementation("com.squareup:javapoet:1.13.0")
+    implementation(project(":paper-api"))
+    implementation("io.github.classgraph:classgraph:4.8.47")
+    implementation("org.jetbrains:annotations:24.0.1")
+    testImplementation("org.junit.jupiter:junit-jupiter:5.10.2")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+}
+
+tasks.register<JavaExec>("generate") {
+    dependsOn(tasks.check)
+    mainClass.set("io.papermc.generator.Main")
+    classpath(sourceSets.main.map { it.runtimeClasspath })
+    args(projectDir.toPath().resolve("generated").toString())
+}
+
+tasks.test {
+    useJUnitPlatform()
+}
+
+group = "io.papermc.paper"
+version = "1.0-SNAPSHOT"

paper-server-generator/src/main/java/io/papermc/generator/Generators.java

@@ -0,0 +1,11 @@
+package io.papermc.generator;
+
+import io.papermc.generator.types.EntityMetaWatcherGenerator;
+import io.papermc.generator.types.SourceGenerator;
+
+public interface Generators {
+
+    SourceGenerator[] SERVER = {
+        new EntityMetaWatcherGenerator("EntityMetaWatcher", "io.papermc.paper.entity.meta")
+    };
+}

paper-server-generator/src/main/java/io/papermc/generator/Main.java

@@ -0,0 +1,64 @@
+package io.papermc.generator;
+
+import com.mojang.logging.LogUtils;
+
+import io.papermc.generator.types.SourceGenerator;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import net.minecraft.SharedConstants;
+import net.minecraft.core.LayeredRegistryAccess;
+import net.minecraft.core.RegistryAccess;
+import net.minecraft.resources.RegistryDataLoader;
+import net.minecraft.server.Bootstrap;
+import net.minecraft.server.RegistryLayer;
+import net.minecraft.server.WorldLoader;
+import net.minecraft.server.packs.PackType;
+import net.minecraft.server.packs.repository.Pack;
+import net.minecraft.server.packs.repository.PackRepository;
+import net.minecraft.server.packs.repository.ServerPacksSource;
+import net.minecraft.server.packs.resources.MultiPackResourceManager;
+import org.apache.commons.io.file.PathUtils;
+import org.slf4j.Logger;
+
+public final class Main {
+
+    private static final Logger LOGGER = LogUtils.getLogger();
+    public static final RegistryAccess.Frozen REGISTRY_ACCESS;
+
+    static {
+        SharedConstants.tryDetectVersion();
+        Bootstrap.bootStrap();
+        final PackRepository resourceRepository = ServerPacksSource.createVanillaTrustedRepository();
+        resourceRepository.reload();
+        final MultiPackResourceManager resourceManager = new MultiPackResourceManager(PackType.SERVER_DATA, resourceRepository.getAvailablePacks().stream().map(Pack::open).toList());
+        LayeredRegistryAccess<RegistryLayer> layers = RegistryLayer.createRegistryAccess();
+        layers = WorldLoader.loadAndReplaceLayer(resourceManager, layers, RegistryLayer.WORLDGEN, RegistryDataLoader.WORLDGEN_REGISTRIES);
+        REGISTRY_ACCESS = layers.compositeAccess().freeze();
+    }
+
+    private Main() {
+    }
+
+    public static void main(final String[] args) {
+        LOGGER.info("Running API generators...");
+        generate(Paths.get(args[0]), Generators.SERVER);
+    }
+
+    private static void generate(Path output, SourceGenerator[] generators) {
+        try {
+            if (Files.exists(output)) {
+                PathUtils.deleteDirectory(output);
+            }
+            Files.createDirectories(output);
+
+            for (final SourceGenerator generator : generators) {
+                generator.writeToFile(output);
+            }
+
+            LOGGER.info("Files written to {}", output.toAbsolutePath());
+        } catch (final Exception ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+}

paper-server-generator/src/main/java/io/papermc/generator/types/EntityMetaWatcherGenerator.java

@@ -0,0 +1,178 @@
+package io.papermc.generator.types;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.WildcardTypeName;
+import io.github.classgraph.ClassGraph;
+import io.github.classgraph.ScanResult;
+import io.papermc.generator.utils.Annotations;
+import io.papermc.generator.utils.ReflectionHelper;
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+import javax.lang.model.element.Modifier;
+import net.minecraft.network.syncher.EntityDataAccessor;
+import net.minecraft.network.syncher.EntityDataSerializer;
+import net.minecraft.network.syncher.EntityDataSerializers;
+import net.minecraft.world.entity.Entity;
+import org.apache.commons.lang3.StringUtils;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.checkerframework.framework.qual.DefaultQualifier;
+
+@DefaultQualifier(NonNull.class)
+public class EntityMetaWatcherGenerator extends SimpleGenerator {
+
+    private static final ParameterizedTypeName GENERIC_ENTITY_DATA_SERIALIZER = ParameterizedTypeName.get(ClassName.get(Map.class), ClassName.get(Long.class), ParameterizedTypeName.get(ClassName.get(EntityDataSerializer.class), WildcardTypeName.subtypeOf(Object.class)));
+    private static final ParameterizedTypeName ENTITY_CLASS = ParameterizedTypeName.get(ClassName.get(Class.class), WildcardTypeName.subtypeOf(Entity.class));
+    private static final ParameterizedTypeName OUTER_MAP_TYPE = ParameterizedTypeName.get(ClassName.get(Map.class), ENTITY_CLASS, GENERIC_ENTITY_DATA_SERIALIZER);
+
+    public EntityMetaWatcherGenerator(String className, String packageName) {
+        super(className, packageName);
+    }
+
+    @Override
+    protected TypeSpec getTypeSpec() {
+        Map<EntityDataSerializer<?>, String> dataAccessorStringMap = serializerMap();
+
+        List<Class<?>> classes;
+        try (ScanResult scanResult = new ClassGraph().enableAllInfo().whitelistPackages("net.minecraft").scan()) {
+            classes = scanResult.getSubclasses(net.minecraft.world.entity.Entity.class.getName()).loadClasses();
+        }
+
+        classes = classes.stream()
+            .filter(clazz -> !java.lang.reflect.Modifier.isAbstract(clazz.getModifiers()))
+            .toList();
+
+        record Pair(Class<?> clazz, List<? extends EntityDataAccessor<?>> metaResults) {}
+
+        final List<Pair> list = classes.stream()
+            .map(clazz -> new Pair(
+                clazz,
+                    ReflectionHelper.getAllForAllParents(clazz, EntityMetaWatcherGenerator::doFilter)
+                        .stream()
+                        .map(this::createData)
+                        .filter(Objects::nonNull)
+                        .toList()
+                )
+            )
+            .toList();
+
+        Map<Class<?>, List<? extends EntityDataAccessor<?>>> vanillaNames = list.stream()
+            .collect(Collectors.toMap(pair -> pair.clazz, pair -> pair.metaResults));
+
+        TypeSpec.Builder typeBuilder = TypeSpec.classBuilder(this.className)
+            .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+            .addAnnotations(Annotations.CLASS_HEADER);
+
+        generateIdAccessorMethods(vanillaNames, dataAccessorStringMap, typeBuilder);
+        generateClassToTypeMap(typeBuilder, vanillaNames.keySet());
+        generateIsValidAccessorForEntity(typeBuilder);
+
+        return typeBuilder.build();
+    }
+
+    private void generateIsValidAccessorForEntity(TypeSpec.Builder builder) {
+        var methodBuilder = MethodSpec.methodBuilder("isValidForClass")
+            .addModifiers(Modifier.PUBLIC, Modifier.FINAL, Modifier.STATIC)
+            .returns(boolean.class)
+            .addParameter(ParameterizedTypeName.get(ClassName.get(Class.class), WildcardTypeName.subtypeOf(Entity.class)), "clazz")
+            .addParameter(EntityDataAccessor.class, "accessor")
+            .addStatement("Map<Long, EntityDataSerializer<?>> serializerMap = VALID_ENTITY_META_MAP.get(clazz)")
+            .beginControlFlow("if(serializerMap == null)")
+            .addStatement("return false")
+            .endControlFlow()
+            .addStatement("var serializer = serializerMap.get(accessor.id())")
+            .addStatement("return serializer != null && serializer == accessor.serializer()");
+
+        builder.addMethod(methodBuilder.build());
+    }
+
+    private void generateClassToTypeMap(TypeSpec.Builder typeBuilder, Set<Class<?>> classes){
+        typeBuilder.addField(
+            FieldSpec.builder(OUTER_MAP_TYPE, "VALID_ENTITY_META_MAP", Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL)
+                .initializer("initialize()")
+                .build()
+        );
+
+        MethodSpec.Builder builder = MethodSpec.methodBuilder("initialize")
+            .addModifiers(Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL)
+            .returns(OUTER_MAP_TYPE)
+            .addStatement("$T result = new $T<>()", OUTER_MAP_TYPE, ClassName.get(HashMap.class));
+
+        classes.forEach(aClass -> {
+            String name = StringUtils.uncapitalize(aClass.getSimpleName());
+            if(!name.isBlank()) {
+                builder.addStatement("result.put($T.class, $L())", aClass, name);
+            }
+        });
+
+        typeBuilder.addMethod(builder.addStatement("return $T.copyOf(result)", Map.class).build());
+    }
+
+    private static void generateIdAccessorMethods(Map<Class<?>, List<? extends EntityDataAccessor<?>>> vanillaNames, Map<EntityDataSerializer<?>, String> dataAccessorStringMap, TypeSpec.Builder typeBuilder) {
+        for (final Map.Entry<Class<?>, List<? extends EntityDataAccessor<?>>> perClassResults : vanillaNames.entrySet()) {
+            if (perClassResults.getKey().getSimpleName().isBlank()) {
+                continue;
+            }
+            var simpleName = perClassResults.getKey().getSimpleName();
+
+            ClassName hashMap = ClassName.get(HashMap.class);
+
+            MethodSpec.Builder builder = MethodSpec.methodBuilder(StringUtils.uncapitalize(simpleName))
+                .addModifiers(Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL)
+                .returns(GENERIC_ENTITY_DATA_SERIALIZER)
+                .addStatement("$T result = new $T<>()", GENERIC_ENTITY_DATA_SERIALIZER, hashMap);
+
+            perClassResults.getValue().forEach(result -> {
+                builder.addStatement("result.put($LL, $T.$L)", result.id(), EntityDataSerializers.class, dataAccessorStringMap.get(result.serializer()));
+            });
+
+            var method = builder.addStatement("return $T.copyOf(result)", Map.class)
+                .build();
+
+            typeBuilder.addMethod(method);
+        }
+    }
+
+    private @Nullable EntityDataAccessor<?> createData(Field field) {
+        try {
+            field.setAccessible(true);
+             return (EntityDataAccessor<?>) field.get(null);
+        } catch (IllegalAccessException e) {
+            return null;
+        }
+    }
+
+    private static boolean doFilter(Field field) {
+        return java.lang.reflect.Modifier.isStatic(field.getModifiers()) && field.getType().isAssignableFrom(EntityDataAccessor.class);
+    }
+
+    @Override
+    protected JavaFile.Builder file(JavaFile.Builder builder) {
+        return builder.skipJavaLangImports(true);
+    }
+
+    private Map<EntityDataSerializer<?>, String> serializerMap(){
+        return Arrays.stream(EntityDataSerializers.class.getDeclaredFields())
+            .filter(field -> field.getType() == EntityDataSerializer.class)
+            .map(field -> {
+                try {
+                    return Map.entry((EntityDataSerializer<?>)field.get(0), field.getName());
+                } catch (IllegalAccessException e) {
+                    return null;
+                }
+            })
+            .filter(Objects::nonNull)
+            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+    }
+}

paper-server-generator/src/main/java/io/papermc/generator/types/SimpleGenerator.java

@@ -0,0 +1,37 @@
+package io.papermc.generator.types;
+
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.TypeSpec;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+public abstract class SimpleGenerator implements SourceGenerator {
+
+    protected final String className;
+    protected final String packageName;
+
+    protected SimpleGenerator(String className, String packageName) {
+        this.className = className;
+        this.packageName = packageName;
+    }
+
+    protected abstract TypeSpec getTypeSpec();
+
+    protected abstract JavaFile.Builder file(JavaFile.Builder builder);
+
+    @Override
+    public void writeToFile(Path parent) throws IOException {
+        Path packagePath = parent.resolve(this.packageName.replace('.', '/'));
+        Files.createDirectories(packagePath);
+
+        JavaFile.Builder builder = JavaFile.builder(this.packageName, this.getTypeSpec())
+            .indent("    ");
+        this.file(builder);
+
+        Files.writeString(packagePath.resolve(this.className + ".java"), this.file(builder).build().toString(), StandardCharsets.UTF_8);
+    }
+
+}

paper-server-generator/src/main/java/io/papermc/generator/types/SourceGenerator.java

@@ -0,0 +1,9 @@
+package io.papermc.generator.types;
+
+import java.io.IOException;
+import java.nio.file.Path;
+
+public interface SourceGenerator {
+
+    void writeToFile(Path parent) throws IOException;
+}

paper-server-generator/src/main/java/io/papermc/generator/utils/Annotations.java

@@ -0,0 +1,59 @@
+package io.papermc.generator.utils;
+
+import com.squareup.javapoet.AnnotationSpec;
+import java.util.List;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.SharedConstants;
+import org.bukkit.MinecraftExperimental;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public final class Annotations {
+
+    public static List<AnnotationSpec> experimentalAnnotations(final String version) {
+        return List.of(
+            AnnotationSpec.builder(ApiStatus.Experimental.class).build(),
+            AnnotationSpec.builder(MinecraftExperimental.class)
+                .addMember("value", "$S", version)
+                .build()
+        );
+    }
+
+    public static AnnotationSpec deprecatedVersioned(final @Nullable String version, boolean forRemoval) {
+        AnnotationSpec.Builder annotationSpec = AnnotationSpec.builder(Deprecated.class);
+        if (forRemoval) {
+            annotationSpec.addMember("forRemoval", "$L", forRemoval);
+        }
+        if (version != null) {
+            annotationSpec.addMember("since", "$S", version);
+        }
+
+        return annotationSpec.build();
+    }
+
+    public static AnnotationSpec scheduledRemoval(final @Nullable String version) {
+        return AnnotationSpec.builder(ApiStatus.ScheduledForRemoval.class)
+            .addMember("inVersion", "$S", version)
+            .build();
+    }
+
+    @ApiStatus.Experimental
+    public static final AnnotationSpec EXPERIMENTAL_API_ANNOTATION = AnnotationSpec.builder(ApiStatus.Experimental.class).build();
+    public static final AnnotationSpec NOT_NULL = AnnotationSpec.builder(NotNull.class).build();
+    private static final AnnotationSpec SUPPRESS_WARNINGS = AnnotationSpec.builder(SuppressWarnings.class)
+        .addMember("value", "$S", "unused")
+        .addMember("value", "$S", "SpellCheckingInspection")
+        .build();
+    private static final AnnotationSpec GENERATED_FROM = AnnotationSpec.builder(GeneratedFrom.class)
+        .addMember("value", "$S", SharedConstants.getCurrentVersion().getName())
+        .build();
+    public static final Iterable<AnnotationSpec> CLASS_HEADER = List.of(
+        SUPPRESS_WARNINGS,
+        GENERATED_FROM
+    );
+
+    private Annotations() {
+    }
+}

paper-server-generator/src/main/java/io/papermc/generator/utils/CollectingContext.java

@@ -0,0 +1,28 @@
+package io.papermc.generator.utils;
+
+import com.mojang.serialization.Lifecycle;
+import io.papermc.generator.Main;
+import java.util.List;
+import net.minecraft.core.Holder;
+import net.minecraft.core.HolderGetter;
+import net.minecraft.core.Registry;
+import net.minecraft.data.worldgen.BootstrapContext;
+import net.minecraft.resources.ResourceKey;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.framework.qual.DefaultQualifier;
+
+@DefaultQualifier(NonNull.class)
+public record CollectingContext<T>(List<ResourceKey<T>> registered,
+                                   Registry<T> registry) implements BootstrapContext<T> {
+
+    @Override
+    public Holder.Reference<T> register(final ResourceKey<T> resourceKey, final @NonNull T t, final Lifecycle lifecycle) {
+        this.registered.add(resourceKey);
+        return Holder.Reference.createStandAlone(this.registry.holderOwner(), resourceKey);
+    }
+
+    @Override
+    public <S> HolderGetter<S> lookup(final ResourceKey<? extends Registry<? extends S>> resourceKey) {
+        return Main.REGISTRY_ACCESS.registryOrThrow(resourceKey).asLookup();
+    }
+}

paper-server-generator/src/main/java/io/papermc/generator/utils/Formatting.java

@@ -0,0 +1,15 @@
+package io.papermc.generator.utils;
+
+import net.kyori.adventure.key.Key;
+
+import java.util.Locale;
+
+public final class Formatting {
+
+    public static String formatKeyAsField(Key key) {
+       return key.value().toUpperCase(Locale.ENGLISH).replaceAll("[.-/]", "_"); // replace invalid field name chars
+    }
+
+    private Formatting() {
+    }
+}

paper-server-generator/src/main/java/io/papermc/generator/utils/Javadocs.java

@@ -0,0 +1,27 @@
+package io.papermc.generator.utils;
+
+public final class Javadocs {
+
+    public static String getVersionDependentClassHeader(String headerIdentifier) {
+        return """
+        Vanilla keys for %s.
+        
+        @apiNote The fields provided here are a direct representation of
+        what is available from the vanilla game source. They may be
+        changed (including removals) on any Minecraft version
+        bump, so cross-version compatibility is not provided on the
+        same level as it is on most of the other API.
+        """.formatted(headerIdentifier);
+    }
+
+    public static String getVersionDependentField(String headerIdentifier) {
+        return """
+        %s
+        
+        @apiNote This field is version-dependant and may be removed in future Minecraft versions
+        """.formatted(headerIdentifier);
+    }
+
+    private Javadocs() {
+    }
+}

paper-server-generator/src/main/java/io/papermc/generator/utils/ReflectionHelper.java

@@ -0,0 +1,39 @@
+package io.papermc.generator.utils;
+
+import io.papermc.generator.types.EntityMetaWatcherGenerator;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Predicate;
+
+public final class ReflectionHelper {
+    private ReflectionHelper(){}
+
+    public static List<Field> getAllForAllParents(Class<?> clazz, Predicate<Field> filter) {
+        List<Field> allClasses = new ArrayList<>(forClass(clazz, filter));
+        for (final Class<?> aClass : allParents(clazz)) {
+            allClasses.addAll(forClass(aClass, filter));
+        }
+        return allClasses;
+    }
+
+    public static List<Class<?>> allParents(Class<?> clazz){
+        List<Class<?>> allClasses = new ArrayList<>();
+        Class<?> current = clazz;
+        while (current.getSuperclass() != null) {
+            var toAdd = current.getSuperclass();
+            if (net.minecraft.world.entity.Entity.class.isAssignableFrom(toAdd)) {
+                allClasses.add(toAdd);
+            }
+            current = toAdd;
+        }
+        Collections.reverse(allClasses);
+        return allClasses;
+    }
+
+    public static List<Field> forClass(Class<?> clazz, Predicate<Field> filter) {
+        return Arrays.stream(clazz.getDeclaredFields()).filter(filter).toList();
+    }
+}

paper-server-generator/wideners.at

@@ -0,0 +1,7 @@
+public net/minecraft/server/WorldLoader loadAndReplaceLayer(Lnet/minecraft/server/packs/resources/ResourceManager;Lnet/minecraft/core/LayeredRegistryAccess;Lnet/minecraft/server/RegistryLayer;Ljava/util/List;)Lnet/minecraft/core/LayeredRegistryAccess;
+
+# for auto-marking experimental stuff
+public net/minecraft/core/RegistrySetBuilder entries
+public net/minecraft/core/RegistrySetBuilder$RegistryStub
+public net/minecraft/data/registries/UpdateOneTwentyOneRegistries BUILDER
+public net/minecraft/data/registries/VanillaRegistries BUILDER

patches/api/0487-add-disguise-api.patch

@@ -0,0 +1,236 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Yannick Lamprecht <yannicklamprecht@live.de>
+Date: Wed, 27 Dec 2023 14:51:59 +0100
+Subject: [PATCH] add disguise api
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/SkinParts.java b/src/main/java/com/destroystokyo/paper/SkinParts.java
+index 4a0c39405d4fbed457787e3c6ded4cc6591bc8c2..c4cc74b95bd1a8378c53a6dee68875991a68bec6 100644
+--- a/src/main/java/com/destroystokyo/paper/SkinParts.java
++++ b/src/main/java/com/destroystokyo/paper/SkinParts.java
+@@ -17,4 +17,15 @@ public interface SkinParts {
+     boolean hasHatsEnabled();
+ 
+     int getRaw();
++
++    interface Builder {
++        @org.jetbrains.annotations.NotNull Builder withCape(boolean cape);
++        @org.jetbrains.annotations.NotNull Builder withJacket(boolean jacket);
++        @org.jetbrains.annotations.NotNull Builder withLeftSleeve(boolean leftSleeve);
++        @org.jetbrains.annotations.NotNull Builder withRightSleeve(boolean rightSleeve);
++        @org.jetbrains.annotations.NotNull Builder withLeftPants(boolean leftPants);
++        @org.jetbrains.annotations.NotNull Builder withRightPants(boolean rightPants);
++        @org.jetbrains.annotations.NotNull Builder withHat(boolean hat);
++        @org.jetbrains.annotations.NotNull SkinParts build();
++    }
+ }
+diff --git a/src/main/java/io/papermc/paper/disguise/DisguiseData.java b/src/main/java/io/papermc/paper/disguise/DisguiseData.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..3bcc252eac8b47eae54d2dff976eec95670a90d3
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/disguise/DisguiseData.java
+@@ -0,0 +1,61 @@
++package io.papermc.paper.disguise;
++
++import com.destroystokyo.paper.profile.PlayerProfile;
++import org.bukkit.entity.EntityType;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Represents the data used to disguise an entity as another.
++ * Also supports disguising an entity as a player commonly known as `FakePlayer`.
++ */
++public sealed interface DisguiseData permits DisguiseData.OriginalDisguise, EntityTypeDisguise, PlayerDisguise {
++
++    /**
++     * Creates an original disguise data that can be used to reset disguising.
++     * <p>
++     * The original instance is set by default when a new entity is spawned
++     * and represents the state of no disguise should be made.
++     * <p>
++     * Same as {@link #reset()}
++     *
++     * @return an original disguise data
++     */
++    static @NotNull DisguiseData original() {
++        return reset();
++    }
++
++    /**
++     * Creates a {@link PlayerDisguise.Builder} where you can configure certain properties of the fake player appearance.
++     *
++     *
++     * @param playerProfile a already completed player profile that will be the fake players skin
++     * @return a builder to configure certain attributes
++     */
++    static @NotNull PlayerDisguise.Builder player(@NotNull PlayerProfile playerProfile) {
++        return new PlayerDisguise.Builder(playerProfile);
++    }
++
++    /**
++     * Creates a {@link EntityTypeDisguise} to allow disguising your entity as the given {@link EntityType}.
++     *
++     *
++     * @param entityType the entity type as which the entity should appear as.
++     * @return an entity disguise
++     */
++    static @NotNull EntityTypeDisguise entity(@NotNull EntityType entityType) {
++        return new EntityTypeDisguise(entityType);
++    }
++
++    /**
++     * An alias for {@link #original()} to cover certain views on it.
++     *
++     * @see #original()
++     *
++     * @return an original disguise data
++     */
++    static @NotNull OriginalDisguise reset() {
++        return new OriginalDisguise();
++    }
++
++    record OriginalDisguise() implements DisguiseData{}
++}
+diff --git a/src/main/java/io/papermc/paper/disguise/EntityTypeDisguise.java b/src/main/java/io/papermc/paper/disguise/EntityTypeDisguise.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..7f63227b1b8bf1e8c98e71979feeeb47bcda0d8b
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/disguise/EntityTypeDisguise.java
+@@ -0,0 +1,13 @@
++package io.papermc.paper.disguise;
++
++import java.util.Objects;
++import org.bukkit.entity.EntityType;
++import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.NotNull;
++
++@ApiStatus.Internal
++public record EntityTypeDisguise(@NotNull EntityType entityType) implements DisguiseData {
++    public EntityTypeDisguise {
++        Objects.requireNonNull(entityType, "type cannot be null");
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/disguise/PlayerDisguise.java b/src/main/java/io/papermc/paper/disguise/PlayerDisguise.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..24afc6a26d9b19c647a55d80e845fa9adcf07a63
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/disguise/PlayerDisguise.java
+@@ -0,0 +1,63 @@
++package io.papermc.paper.disguise;
++
++import com.destroystokyo.paper.SkinParts;
++import com.destroystokyo.paper.profile.PlayerProfile;
++import java.util.Objects;
++import org.bukkit.Server;
++import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++@ApiStatus.Internal
++public record PlayerDisguise(@NotNull PlayerProfile playerProfile, boolean listed, @Nullable SkinParts skinParts) implements DisguiseData {
++
++    public  PlayerDisguise {
++        Objects.requireNonNull(playerProfile, "profile cannot be null");
++    }
++    public static @NotNull Builder builder(@NotNull PlayerProfile playerProfile) {
++        return new Builder(playerProfile);
++    }
++
++    /**
++     * Represents the builder to configure certain appearance settings.
++     */
++    public static class Builder {
++        private final PlayerProfile playerProfile;
++        private boolean listed;
++        private SkinParts skinParts;
++
++        @ApiStatus.Internal
++        public Builder(@NotNull PlayerProfile playerProfile) {
++            this.playerProfile = playerProfile;
++        }
++
++        /**
++         * Defines if the fake player will be shown in player list.
++         *
++         * @param listed true, if the player should be listed else false
++         * @return the builder instance
++         */
++        public @NotNull Builder listed(boolean listed) {
++            this.listed = listed;
++            return this;
++        }
++
++        /**
++         *  Defines which skin parts should be enabled for the fake player.
++         *  <p>
++         *  Use {@link Server#newSkinPartsBuilder()} to get a fresh builder instance for configuration.
++         *
++         * @param skinParts the skin parts that should be shown.
++         * @return the builder instance
++         */
++        public @NotNull Builder skinParts(@NotNull SkinParts skinParts) {
++            this.skinParts = skinParts;
++            return this;
++        }
++
++        @ApiStatus.Internal
++        public @NotNull PlayerDisguise build() {
++            return new PlayerDisguise(playerProfile, listed, skinParts);
++        }
++    }
++}
+diff --git a/src/main/java/org/bukkit/Server.java b/src/main/java/org/bukkit/Server.java
+index 5aa64ea39ebd92e5067c53cea49a8685c0b9eee4..f8567b1093f3580bc8c7f219ee1021a435c775d8 100644
+--- a/src/main/java/org/bukkit/Server.java
++++ b/src/main/java/org/bukkit/Server.java
+@@ -2554,4 +2554,11 @@ public interface Server extends PluginMessageRecipient, net.kyori.adventure.audi
+      */
+     boolean isOwnedByCurrentRegion(@NotNull Entity entity);
+     // Paper end - Folia region threading API
++    // Paper start - add disguise api
++    /**
++     * Creates a new skinparts builder used for overriding skin settings
++     * @return a new builder for skin parts
++     */
++    com.destroystokyo.paper.SkinParts.@NotNull Builder newSkinPartsBuilder();
++    // Paper end - add disguise api
+ }
+diff --git a/src/main/java/org/bukkit/entity/Entity.java b/src/main/java/org/bukkit/entity/Entity.java
+index 725ef320f929d5e3d141c1ed3246d73a7d741f31..d159839f3ddcb01d295d12b8562aff529d74d9a3 100644
+--- a/src/main/java/org/bukkit/entity/Entity.java
++++ b/src/main/java/org/bukkit/entity/Entity.java
+@@ -1159,4 +1159,34 @@ public interface Entity extends Metadatable, CommandSender, Nameable, Persistent
+      */
+     @NotNull String getScoreboardEntryName();
+     // Paper end - entity scoreboard name
++    // Paper start - disguise api
++
++    /**
++     * Gets the current {@link io.papermc.paper.disguise.DisguiseData} of the entity.
++     *
++     * @return {@link io.papermc.paper.disguise.DisguiseData.OriginalDisguise} if entity is not disguised.
++     * Otherwise, one of {@link io.papermc.paper.disguise.EntityTypeDisguise} or {@link io.papermc.paper.disguise.PlayerDisguise}
++     */
++    @NotNull io.papermc.paper.disguise.DisguiseData getDisguiseData();
++
++    /**
++     * Sets the current {@link io.papermc.paper.disguise.DisguiseData} of the entity.
++     * <p>
++     * Following {@link io.papermc.paper.disguise.DisguiseData} can be set:
++     * <ul>
++     *     <li>{@link io.papermc.paper.disguise.PlayerDisguise} use {@link io.papermc.paper.disguise.DisguiseData#player(com.destroystokyo.paper.profile.PlayerProfile)}.
++     *     It returns a builder where you are able to configure additional settings</li>
++     *     <li>{@link io.papermc.paper.disguise.EntityTypeDisguise} use {@link io.papermc.paper.disguise.DisguiseData#entity(EntityType)}</li>
++     *     <li>{@link io.papermc.paper.disguise.DisguiseData.OriginalDisguise} use {@link io.papermc.paper.disguise.DisguiseData#original()} or {@link io.papermc.paper.disguise.DisguiseData#reset()} to reset it again to the original state</li>
++     * </ul>
++     * <p>
++     * The following entities are not supported:
++     * <ul>
++     *     <li>{@link ExperienceOrb}</li>
++     * </ul>
++     *
++     * @param disguiseData the {@link io.papermc.paper.disguise.DisguiseData} that will be set.
++     */
++    void setDisguiseData(@NotNull io.papermc.paper.disguise.DisguiseData disguiseData);
++    // Paper end - disguise api
+ }

patches/server/1056-add-paper-server-generator-dependency.patch

@@ -0,0 +1,59 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Yannick Lamprecht <yannicklamprecht@live.de>
+Date: Mon, 11 Mar 2024 00:52:56 +0100
+Subject: [PATCH] add paper server generator dependency
+
+
+diff --git a/build.gradle.kts b/build.gradle.kts
+index 3588770a9ea6ee0a9508b218758650f43d994715..69829e3ae5dcb6110f3630fdab927ccb93b33aad 100644
+--- a/build.gradle.kts
++++ b/build.gradle.kts
+@@ -4,6 +4,7 @@ import java.time.Instant
+ plugins {
+     java
+     `maven-publish`
++    idea // Paper
+ }
+ 
+ val log4jPlugins = sourceSets.create("log4jPlugins")
+@@ -67,6 +68,22 @@ dependencies {
+     // Paper end - spark
+ }
+ 
++// Paper start
++val generatedServerPath: java.nio.file.Path = rootProject.projectDir.toPath().resolve("paper-server-generator/generated")
++idea {
++    module {
++        generatedSourceDirs.add(generatedServerPath.toFile())
++    }
++}
++sourceSets {
++    main {
++        java {
++            srcDir(generatedServerPath)
++        }
++    }
++}
++// Paper end
++
+ paperweight {
+     craftBukkitPackageVersion.set("v1_21_R1") // also needs to be updated in MappingEnvironment
+ }
+@@ -125,6 +142,17 @@ tasks.check {
+     dependsOn(scanJar)
+ }
+ // Paper end
++// Paper start
++val scanJarForOldGeneratedCode = tasks.register("scanJarForOldGeneratedCode", io.papermc.paperweight.tasks.ScanJarForOldGeneratedCode::class) {
++    mcVersion.set(providers.gradleProperty("mcVersion"))
++    annotation.set("Lio/papermc/paper/generated/GeneratedFrom;")
++    jarToScan.set(tasks.jar.flatMap { it.archiveFile })
++    classpath.from(configurations.compileClasspath)
++}
++tasks.check {
++    dependsOn(scanJarForOldGeneratedCode)
++}
++// Paper end
+ // Paper start - use TCA for console improvements
+ tasks.serverJar {
+     from(alsoShade.elements.map {

patches/server/1057-add-disguise-api.patch

@@ -0,0 +1,360 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Yannick Lamprecht <yannicklamprecht@live.de>
+Date: Sat, 16 Mar 2024 22:58:19 +0100
+Subject: [PATCH] add disguise api
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperSkinParts.java b/src/main/java/com/destroystokyo/paper/PaperSkinParts.java
+index b6f4400df3d8ec7e06a996de54f8cabba57885e1..23a6026dda4ce5befa1d5e78b0434c2738555ff9 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperSkinParts.java
++++ b/src/main/java/com/destroystokyo/paper/PaperSkinParts.java
+@@ -71,4 +71,81 @@ public class PaperSkinParts implements SkinParts {
+             .add("hats=" + hasHatsEnabled())
+             .toString();
+     }
++
++    public static SkinParts.Builder builder(){
++        return new Builder();
++    }
++
++    public static class Builder implements SkinParts.Builder {
++
++        private boolean cape;
++        private boolean jacket;
++        private boolean leftSleeve;
++        private boolean rightSleeve;
++        private boolean leftPants;
++        private boolean rightPants;
++        private boolean hats;
++
++        private static final int CAPE = 0x01;
++        private static final int JACKET = 0x02;
++        private static final int LEFT_SLEEVE = 0x04;
++        private static final int RIGHT_SLEEVE = 0x08;
++        private static final int LEFT_PANTS = 0x10;
++        private static final int RIGHT_PANTS = 0x20;
++        private static final int HAT = 0x40;
++
++        @Override
++        public @org.jetbrains.annotations.NotNull Builder withCape(boolean cape) {
++            this.cape = cape;
++            return this;
++        }
++
++        @Override
++        public @org.jetbrains.annotations.NotNull Builder withJacket(boolean jacket) {
++            this.jacket = jacket;
++            return this;
++        }
++
++        @Override
++        public @org.jetbrains.annotations.NotNull Builder withLeftSleeve(boolean leftSleeve) {
++            this.leftSleeve = leftSleeve;
++            return this;
++        }
++
++        @Override
++        public @org.jetbrains.annotations.NotNull Builder withRightSleeve(boolean rightSleeve) {
++            this.rightSleeve = rightSleeve;
++            return this;
++        }
++
++        @Override
++        public @org.jetbrains.annotations.NotNull Builder withLeftPants(boolean leftPants) {
++            this.leftPants = leftPants;
++            return this;
++        }
++
++        @Override
++        public @org.jetbrains.annotations.NotNull Builder withRightPants(boolean rightPants) {
++            this.rightPants = rightPants;
++            return this;
++        }
++
++        @Override
++        public @org.jetbrains.annotations.NotNull Builder withHat(boolean hat) {
++            this.hats = hat;
++            return this;
++        }
++
++        public @org.jetbrains.annotations.NotNull SkinParts build() {
++            int raw = 0;
++            if (cape) raw |= CAPE;
++            if (jacket) raw |= JACKET;
++            if (leftSleeve) raw |= LEFT_SLEEVE;
++            if (rightSleeve) raw |= RIGHT_SLEEVE;
++            if (leftPants) raw |= LEFT_PANTS;
++            if (rightPants) raw |= RIGHT_PANTS;
++            if (hats) raw |= HAT;
++            return new PaperSkinParts(raw);
++        }
++    }
+ }
+diff --git a/src/main/java/io/papermc/paper/disguise/DisguiseUtil.java b/src/main/java/io/papermc/paper/disguise/DisguiseUtil.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..91eac1319ee77d1314f7ea966416ca5aa5334b4d
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/disguise/DisguiseUtil.java
+@@ -0,0 +1,119 @@
++package io.papermc.paper.disguise;
++
++import com.destroystokyo.paper.profile.CraftPlayerProfile;
++import com.destroystokyo.paper.profile.PlayerProfile;
++import java.util.EnumSet;
++import java.util.List;
++import net.minecraft.network.protocol.Packet;
++import net.minecraft.network.protocol.game.ClientboundAddEntityPacket;
++import net.minecraft.network.protocol.game.ClientboundPlayerInfoRemovePacket;
++import net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket;
++import net.minecraft.network.syncher.EntityDataAccessor;
++import net.minecraft.network.syncher.SynchedEntityData;
++import net.minecraft.server.level.ServerPlayer;
++import net.minecraft.world.entity.Entity;
++import net.minecraft.world.entity.EntityType;
++import net.minecraft.world.entity.LivingEntity;
++import net.minecraft.world.entity.ai.attributes.Attribute;
++import net.minecraft.world.entity.player.Player;
++import net.minecraft.world.phys.Vec3;
++import org.bukkit.Bukkit;
++import org.bukkit.craftbukkit.entity.CraftEntityType;
++
++import static net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket.Action;
++import static net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket.Entry;
++
++public final class DisguiseUtil {
++    private DisguiseUtil(){}
++
++    public static boolean tryDisguise(ServerPlayer player, Entity entity, Packet<?> packet) {
++            if(!(packet instanceof ClientboundAddEntityPacket clientboundAddEntityPacket)) {
++                return false;
++            }
++            return switch (entity.getBukkitEntity().getDisguiseData()) {
++                case DisguiseData.OriginalDisguise disguise -> false;
++                case io.papermc.paper.disguise.EntityTypeDisguise(var type) -> {
++                    player.connection.send(create(clientboundAddEntityPacket, CraftEntityType.bukkitToMinecraft(type)));
++                    yield  true;
++                }
++                case PlayerDisguise(var playerProfile, var listed, var skinParts) -> {
++                    PlayerProfile adapted = Bukkit.createProfile(entity.getUUID(), playerProfile.getName());
++                    adapted.setProperties(playerProfile.getProperties());
++                    Entry playerUpdate = new Entry(
++                            entity.getUUID(),
++                            CraftPlayerProfile.asAuthlibCopy(adapted),
++                            listed,
++                            0,
++                            net.minecraft.world.level.GameType.DEFAULT_MODE,
++                            entity.getCustomName(),
++                            null
++                        );
++                    player.connection.send(new ClientboundPlayerInfoUpdatePacket(EnumSet.of(Action.ADD_PLAYER), playerUpdate));
++                    player.connection.send(new ClientboundPlayerInfoUpdatePacket(EnumSet.of(Action.UPDATE_LISTED), playerUpdate));
++                    player.connection.send(create(clientboundAddEntityPacket, net.minecraft.world.entity.EntityType.PLAYER));
++                    if(skinParts != null) {
++                        player.connection.send(new net.minecraft.network.protocol.game.ClientboundSetEntityDataPacket(
++                            clientboundAddEntityPacket.getId(),
++                            List.of(new SynchedEntityData.DataItem<>(Player.DATA_PLAYER_MODE_CUSTOMISATION, (byte) skinParts.getRaw()).value())
++                        ));
++                    }
++                    yield  true;
++                }
++            };
++    }
++
++    /*
++     * Only player disguise needs to be handled specially
++     * because the client doesn't forget the player profile otherwise.
++     * This would result in player being kicked cause the entities type mismatches the previously disguised one.
++     */
++    public static void tryDespawn(ServerPlayer player, Entity entity) {
++        if(entity.getBukkitEntity().getDisguiseData() instanceof PlayerDisguise) {
++            player.connection.send(new ClientboundPlayerInfoRemovePacket(List.of(entity.getUUID())));
++        }
++    }
++
++    private static ClientboundAddEntityPacket create(ClientboundAddEntityPacket packet, EntityType<?> entityType) {
++        return new net.minecraft.network.protocol.game.ClientboundAddEntityPacket(
++            packet.getId(),
++            packet.getUUID(),
++            packet.getX(),
++            packet.getY(),
++            packet.getZ(),
++            packet.getXRot(),
++            packet.getYRot(),
++            entityType,
++            0,
++            Vec3.ZERO.add(packet.getX(), packet.getY(), packet.getZ()).scale(1/8000.0D),
++            packet.getYHeadRot()
++        );
++    }
++
++
++    /*
++     * Is used to skip entity meta that doesn't fit the disguised type.
++     * e.g. Player having a float at index 15 (additional hearts) and the server side entity is an Armorstand
++     * that has a byte at that index.
++     */
++    public static boolean shouldSkip(Entity entity, EntityDataAccessor<?> dataAccessor) {
++        return switch (entity.getBukkitEntity().getDisguiseData()) {
++            case DisguiseData.OriginalDisguise original -> false;
++            case EntityTypeDisguise entityTypeDisguise -> !io.papermc.paper.entity.meta.EntityMetaWatcher.isValidForClass(
++                CraftEntityType.bukkitToMinecraft(entityTypeDisguise.entityType()).getBaseClass(),
++                dataAccessor
++            );
++            case PlayerDisguise playerDisguise -> !io.papermc.paper.entity.meta.EntityMetaWatcher.isValidForClass(
++                ServerPlayer.class,
++                dataAccessor
++            );
++        };
++    }
++
++    public static boolean shouldSkipAttributeSending(Entity entity) {
++        return switch (entity.getBukkitEntity().getDisguiseData()) {
++            case DisguiseData.OriginalDisguise original -> false;
++            case EntityTypeDisguise entityTypeDisguise -> !entityTypeDisguise.entityType().hasDefaultAttributes();
++            case PlayerDisguise playerDisguise -> false;
++        };
++    }
++}
+diff --git a/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java b/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
+index 0f99733660f91280e4c6262cf75b3c9cae86f65a..c49606b5f8e459a1574c3111c10f2c66c0888f87 100644
+--- a/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
++++ b/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
+@@ -100,6 +100,7 @@ public class SynchedEntityData {
+ 
+                 if (datawatcher_item.isDirty()) {
+                     datawatcher_item.setDirty(false);
++                    if (io.papermc.paper.disguise.DisguiseUtil.shouldSkip((net.minecraft.world.entity.Entity) entity, datawatcher_item.getAccessor())) continue; // Paper - disguise api
+                     list.add(datawatcher_item.value());
+                 }
+             }
+@@ -117,6 +118,7 @@ public class SynchedEntityData {
+         for (int j = 0; j < i; ++j) {
+             SynchedEntityData.DataItem<?> datawatcher_item = adatawatcher_item[j];
+ 
++            if (io.papermc.paper.disguise.DisguiseUtil.shouldSkip((net.minecraft.world.entity.Entity) entity, datawatcher_item.getAccessor())) continue; // Paper - disguise api
+             if (!datawatcher_item.isSetToDefault()) {
+                 if (list == null) {
+                     list = new ArrayList();
+@@ -136,6 +138,7 @@ public class SynchedEntityData {
+             SynchedEntityData.DataValue<?> datawatcher_c = (SynchedEntityData.DataValue) iterator.next();
+             SynchedEntityData.DataItem<?> datawatcher_item = this.itemsById[datawatcher_c.id];
+ 
++            if (io.papermc.paper.disguise.DisguiseUtil.shouldSkip((net.minecraft.world.entity.Entity) entity, datawatcher_item.getAccessor())) continue; // Paper - disguise api
+             this.assignValue(datawatcher_item, datawatcher_c);
+             this.entity.onSyncedDataUpdated(datawatcher_item.getAccessor());
+         }
+@@ -158,6 +161,7 @@ public class SynchedEntityData {
+     public List<SynchedEntityData.DataValue<?>> packAll() {
+         final List<SynchedEntityData.DataValue<?>> list = new ArrayList<>();
+         for (final DataItem<?> dataItem : this.itemsById) {
++            if (io.papermc.paper.disguise.DisguiseUtil.shouldSkip((net.minecraft.world.entity.Entity) entity, dataItem.getAccessor())) continue; // Paper - disguise api
+             list.add(dataItem.value());
+         }
+ 
+diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
+index 8ea2f24695f5dad55e21f238b69442513e7a90c6..050639fed4a3f7a38b2a1c126ca4a4d3abec1bd8 100644
+--- a/src/main/java/net/minecraft/server/level/ServerEntity.java
++++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
+@@ -296,6 +296,7 @@ public class ServerEntity {
+ 
+     public void removePairing(ServerPlayer player) {
+         this.entity.stopSeenByPlayer(player);
++        io.papermc.paper.disguise.DisguiseUtil.tryDespawn(player, this.entity); // Paper - disguise api
+         player.connection.send(new ClientboundRemoveEntitiesPacket(new int[]{this.entity.getId()}));
+     }
+ 
+@@ -317,15 +318,18 @@ public class ServerEntity {
+         }
+ 
+         Packet<ClientGamePacketListener> packet = this.entity.getAddEntityPacket(this);
+-
++        // Paper start - disguise api
++        if(!io.papermc.paper.disguise.DisguiseUtil.tryDisguise(player, entity, packet)){
+         sender.accept(packet);
++        }
++        // Paper end - disguise api
+         if (this.trackedDataValues != null) {
+             sender.accept(new ClientboundSetEntityDataPacket(this.entity.getId(), this.trackedDataValues));
+         }
+ 
+         boolean flag = this.trackDelta;
+ 
+-        if (this.entity instanceof LivingEntity) {
++        if (this.entity instanceof LivingEntity && !io.papermc.paper.disguise.DisguiseUtil.shouldSkipAttributeSending(this.entity)) { // Paper - disguise api
+             Collection<AttributeInstance> collection = ((LivingEntity) this.entity).getAttributes().getSyncableAttributes();
+ 
+             // CraftBukkit start - If sending own attributes send scaled health instead of current maximum health
+@@ -423,7 +427,9 @@ public class ServerEntity {
+                     ((ServerPlayer) this.entity).getBukkitEntity().injectScaledMaxHealth(set, false);
+                 }
+                 // CraftBukkit end
++                if(!io.papermc.paper.disguise.DisguiseUtil.shouldSkipAttributeSending(this.entity)) { // Paper start - disguise api
+                 this.broadcastAndSend(new ClientboundUpdateAttributesPacket(this.entity.getId(), set));
++                } // Paper end - disguise api
+             }
+ 
+             set.clear();
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index ccd9dff20a60f019e0c320acfb526b8bf3e5f806..ae3d5017d6d6b7957f779101d19539dae8fde62f 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -1315,6 +1315,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+ 
+     private void refreshDirtyAttributes() {
+         Set<AttributeInstance> set = this.getAttributes().getAttributesToUpdate();
++        if (io.papermc.paper.disguise.DisguiseUtil.shouldSkipAttributeSending(this)) return; // Paper - disguise api
+         Iterator iterator = set.iterator();
+ 
+         while (iterator.hasNext()) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 1b36e94617d4e777c419660936460d5cf8a4b3e8..274e348ed53d30d5b6269cb4f1e5aa60d3926643 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -380,6 +380,12 @@ public final class CraftServer implements Server {
+         return ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(((org.bukkit.craftbukkit.entity.CraftEntity) entity).getHandleRaw());
+     }
+     // Paper end - Folia reagion threading API
++    // Paper start - add disguise api
++    @Override
++    public com.destroystokyo.paper.SkinParts.@org.jetbrains.annotations.NotNull Builder newSkinPartsBuilder() {
++        return com.destroystokyo.paper.PaperSkinParts.builder();
++    }
++    // Paper end - add disguise api
+ 
+     static {
+         ConfigurationSerialization.registerClass(CraftOfflinePlayer.class);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index cd789c235acf740ec29c30b180e7fbe1a140caa9..0ef32950e70a0108635c2ae405a7ca54af9d53dc 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -1299,4 +1299,16 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+         return this.getHandle().getScoreboardName();
+     }
+     // Paper end - entity scoreboard name
++    // Paper start - disguise api
++    private io.papermc.paper.disguise.DisguiseData disguiseData = io.papermc.paper.disguise.DisguiseData.original();
++    @Override
++    public @org.jetbrains.annotations.NotNull io.papermc.paper.disguise.DisguiseData getDisguiseData() {
++        return disguiseData;
++    }
++
++    @Override
++    public void setDisguiseData(@org.jetbrains.annotations.NotNull io.papermc.paper.disguise.DisguiseData disguiseData) {
++        this.disguiseData = disguiseData;
++    }
++    // Paper end - disguise api
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index a0d5082590ee03060f0dbb4770d196efc316c328..efb470589a72ed6922cd8908752743aceb1149fa 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -2834,7 +2834,9 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+ 
+         // SPIGOT-3813: Attributes before health
+         if (this.getHandle().connection != null) {
++            if(!io.papermc.paper.disguise.DisguiseUtil.shouldSkipAttributeSending(this.getHandle())){ // Paper start - disguise api
+             this.getHandle().connection.send(new ClientboundUpdateAttributesPacket(this.getHandle().getId(), set));
++            } // Paper end - disguise api
+             if (sendHealth) {
+                 this.sendHealthUpdate();
+             }

settings.gradle.kts

@@ -41,6 +41,7 @@ for (name in listOf("Paper-API", "Paper-Server")) {
 
 optionalInclude("test-plugin")
 optionalInclude("paper-api-generator")
+optionalInclude("paper-server-generator")
 
 fun optionalInclude(name: String, op: (ProjectDescriptor.() -> Unit)? = null) {
     val settingsFile = file("$name.settings.gradle.kts")