[ci skip] Cleanup unapplied patches

patches/server/0012-Optimize-default-configurations.patch

@@ -8,6 +8,18 @@ Subject: [PATCH] Optimize default configurations
 - AkiraDevelopment/SimplyMC
 - YouHaveTrouble/minecraft-exploits-and-how-to-fix-them
 
+diff --git a/src/main/java/io/papermc/paper/configuration/WorldConfiguration.java b/src/main/java/io/papermc/paper/configuration/WorldConfiguration.java
+index c867796f6..ecced2072 100644
+--- a/src/main/java/io/papermc/paper/configuration/WorldConfiguration.java
++++ b/src/main/java/io/papermc/paper/configuration/WorldConfiguration.java
+@@ -181,7 +222,7 @@ public class WorldConfiguration extends ConfigurationPart {
+             @MergeMap
+             public Reference2IntMap<MobCategory> spawnLimits = Util.make(new Reference2IntOpenHashMap<>(NaturalSpawner.SPAWNING_CATEGORIES.length), map -> Arrays.stream(NaturalSpawner.SPAWNING_CATEGORIES).forEach(mobCategory -> map.put(mobCategory, -1)));
+             @MergeMap
+-            public Map<MobCategory, DespawnRange> despawnRanges = Arrays.stream(MobCategory.values()).collect(Collectors.toMap(Function.identity(), category -> new DespawnRange(category.getNoDespawnDistance(), category.getDespawnDistance())));
++            public Map<MobCategory, DespawnRange> despawnRanges = Arrays.stream(MobCategory.values()).collect(Collectors.toMap(Function.identity(), category -> new DespawnRange(category.getNoDespawnDistance(), org.plazmamc.plazma.configurations.PlazmaConfigurations.optimize() ? (net.minecraft.server.MinecraftServer.getServer().server.getSimulationDistance() * 16) + 8 : category.getDespawnDistance()))); // Plazma - Optimize default configurations
+             @MergeMap
+             public Reference2IntMap<MobCategory> ticksPerSpawn = Util.make(new Reference2IntOpenHashMap<>(NaturalSpawner.SPAWNING_CATEGORIES.length), map -> Arrays.stream(NaturalSpawner.SPAWNING_CATEGORIES).forEach(mobCategory -> map.put(mobCategory, -1)));
 diff --git a/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java b/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java
 index 3ff4f092a59242a8cb930c084915a774db881652..66f797f5205b9b259cc6f6cfd710293fc73cdf59 100644
 --- a/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java

patches/server/0029-Use-Akair-s-flag-when-running-the-test-server-with-g.patch

@@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: AlphaKR93 <dev@alpha93.kr>
-Date: Mon, 6 May 2024 12:25:59 +0900
-Subject: [PATCH] Use Akair's flag when running the test server with gradle
-
-
-diff --git a/build.gradle.kts b/build.gradle.kts
-index a40dc8b2560b8cd124d961f3dfd5865efd2a3b9e..e4dfd79840913e776a84bacda776329cb32e2be9 100644
---- a/build.gradle.kts
-+++ b/build.gradle.kts
-@@ -164,7 +164,7 @@ fun TaskContainer.registerRunTask(
-         languageVersion.set(JavaLanguageVersion.of(21))
-         vendor.set(JvmVendorSpec.JETBRAINS)
-     })
--    jvmArgs("-XX:+AllowEnhancedClassRedefinition", "-XX:+AllowRedefinitionToAddDeleteMethods")
-+    jvmArgs("-XX:+AllowEnhancedClassRedefinition", "-XX:+AllowRedefinitionToAddDeleteMethods", "--add-modules=jdk.incubator.vector", "-XX:+UseG1GC", "-XX:+ParallelRefProcEnabled", "-XX:MaxGCPauseMillis=200", "-XX:+UnlockExperimentalVMOptions", "-XX:+DisableExplicitGC", "-XX:+AlwaysPreTouch", "-XX:G1HeapWastePercent=5", "-XX:G1MixedGCCountTarget=4", "-XX:InitiatingHeapOccupancyPercent=15", "-XX:G1MixedGCLiveThresholdPercent=90", "-XX:G1RSetUpdatingPauseTimePercent=5", "-XX:SurvivorRatio=32", "-XX:+PerfDisableSharedMem", "-XX:MaxTenuringThreshold=1", "-Dusing.aikars.flags=https://mcflags.emc.gs", "-Daikars.new.flags=true", "-XX:G1NewSizePercent=40", "-XX:G1MaxNewSizePercent=50", "-XX:G1HeapRegionSize=16M", "-XX:G1ReservePercent=15") // Plazma - Always agree EULA on development mode; Use Akair's flag when running the test server with gradle
- 
-     if (rootProject.childProjects["test-plugin"] != null) {
-         val testPluginJar = rootProject.project(":test-plugin").tasks.jar.flatMap { it.archiveFile }

patches/server/0041-Completely-remove-timings-implementation.patch

@@ -1,62 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: AlphaKR93 <dev@alpha93.kr>
-Date: Wed, 15 May 2024 14:12:50 +0900
-Subject: [PATCH] Completely remove timings implementation
-
-
-diff --git a/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java b/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java
-index 23594fb7eb4b2f33146592866608c2858ef23937..8acdea0f086129854cb44bc5ce8bbbc4e810b9ad 100644
---- a/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java
-+++ b/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java
-@@ -1,6 +1,6 @@
- package io.papermc.paper.plugin.manager;
- 
--import co.aikar.timings.TimedEventExecutor;
-+//import co.aikar.timings.TimedEventExecutor; // Plazma - Completely remove timings implementation
- import com.destroystokyo.paper.event.server.ServerExceptionEvent;
- import com.destroystokyo.paper.exception.ServerEventException;
- import com.google.common.collect.Sets;
-@@ -96,7 +96,7 @@ class PaperEventManager {
-             throw new IllegalPluginAccessException("Plugin attempted to register " + event + " while not enabled");
-         }
- 
--        executor = new TimedEventExecutor(executor, plugin, null, event);
-+        //executor = new TimedEventExecutor(executor, plugin, null, event); // Plazma - Completely remove timings implementation
-         this.getEventListeners(event).register(new RegisteredListener(listener, executor, priority, plugin, ignoreCancelled));
-     }
- 
-@@ -183,7 +183,7 @@ class PaperEventManager {
-                 }
-             }
- 
--            EventExecutor executor = new TimedEventExecutor(EventExecutor.create(method, eventClass), plugin, method, eventClass);
-+            EventExecutor executor = EventExecutor.create(method, eventClass); // Plazma - Completely remove timings implementation
-             eventSet.add(new RegisteredListener(listener, executor, eh.priority(), plugin, eh.ignoreCancelled()));
-         }
-         return ret;
-diff --git a/src/main/java/io/papermc/paper/plugin/manager/PaperPluginManagerImpl.java b/src/main/java/io/papermc/paper/plugin/manager/PaperPluginManagerImpl.java
-index 097500a59336db1bbfffcd1aa4cff7a8586e46ec..e0d634d4b0dd6f7c09f61865ed299de782c4abf8 100644
---- a/src/main/java/io/papermc/paper/plugin/manager/PaperPluginManagerImpl.java
-+++ b/src/main/java/io/papermc/paper/plugin/manager/PaperPluginManagerImpl.java
-@@ -232,7 +232,7 @@ public class PaperPluginManagerImpl implements PluginManager, DependencyContext
- 
-     @Override
-     public boolean useTimings() {
--        return co.aikar.timings.Timings.isTimingsEnabled();
-+        return false; // Plazma - Remove remaining timings implementations
-     }
- 
-     @Override
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index 657f118713b2188cb2e7fe5ec3be455189b50623..854f19306100289dabce523c973edcf6fbcdb6cc 100644
---- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -3,7 +3,7 @@ package net.minecraft.server;
- import com.google.common.base.Preconditions;
- import com.google.common.base.Splitter;
- import com.google.common.collect.ImmutableList;
--import co.aikar.timings.Timings;
-+//import co.aikar.timings.Timings; // Plazma - Completely remove timings implementation
- import com.destroystokyo.paper.event.server.PaperServerListPingEvent;
- import com.google.common.base.Stopwatch;
- import com.google.common.collect.Lists;

patches/server/features/outdated/0057-Implement-CarpetFixes.patch

@@ -0,0 +1,227 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: AlphaKR93 <dev@alpha93.kr>
+Date: Sat, 14 Dec 2024 00:29:15 +0900
+Subject: [PATCH] Implement CarpetFixes
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Sheep.java b/src/main/java/net/minecraft/world/entity/animal/Sheep.java
+index 0503f936d0d7194f110069adabff984f51af0a3a..0ca88636cca9b8f93cddf8bc58038e626e171df8 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Sheep.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Sheep.java
+@@ -379,19 +379,22 @@ public class Sheep extends Animal implements Shearable {
+     }
+ 
+     private DyeColor getOffspringColor(ServerLevel world, Sheep firstParent, Sheep secondParent) {
+-        DyeColor enumcolor = firstParent.getColor();
+-        DyeColor enumcolor1 = secondParent.getColor();
+-        CraftingInput craftinginput = Sheep.makeCraftInput(enumcolor, enumcolor1);
+-        Optional<Item> optional = world.recipeAccess().getRecipeFor(RecipeType.CRAFTING, craftinginput, world).map((recipeholder) -> { // CraftBukkit - decompile error
+-            return ((CraftingRecipe) recipeholder.value()).assemble(craftinginput, world.registryAccess());
+-        }).map(ItemStack::getItem);
+-
+-        Objects.requireNonNull(DyeItem.class);
+-        optional = optional.filter(DyeItem.class::isInstance);
+-        Objects.requireNonNull(DyeItem.class);
+-        return (DyeColor) optional.map(DyeItem.class::cast).map(DyeItem::getDyeColor).orElseGet(() -> {
+-            return world.random.nextBoolean() ? enumcolor : enumcolor1;
+-        });
++        // Plazma start - Implement CarpetFixes
++        final DyeColor firstColor = firstParent.getColor();
++        final DyeColor secondColor = secondParent.getColor();
++// PLAZMA - REMOVE THIS
++        if (world.plazmaConfig().carpetFixes.preparedSheepChildColor) {
++            final DyeColor color = org.plazmamc.plazma.util.CarpetFixes.properDyeMixin(firstColor, secondColor);
++            if (color != null) return color;
++            return world.random.nextBoolean() ? firstColor : secondColor;
++        }
++// PLAZMA - REMOVE THIS
++        final CraftingInput input = Sheep.makeCraftInput(firstColor, secondColor);
++// PLAZMA - REMOVE THIS
++        Optional<Item> result = world.recipeAccess().getRecipeFor(RecipeType.CRAFTING, input, world).map((recipeholder) -> recipeholder.value().assemble(input, world.registryAccess())).map(ItemStack::getItem);
++        result = result.filter(DyeItem.class::isInstance);
++        return result.map(DyeItem.class::cast).map(DyeItem::getDyeColor).orElseGet(() -> world.random.nextBoolean() ? firstColor : secondColor);
++        // Plazma end - Implement CarpetFixes
+     }
+ 
+     private static CraftingInput makeCraftInput(DyeColor firstColor, DyeColor secondColor) {
+diff --git a/src/main/java/net/minecraft/world/level/biome/BiomeManager.java b/src/main/java/net/minecraft/world/level/biome/BiomeManager.java
+index 90f8360f547ce709fd13ee34f8e67d8bfa94b498..4e5fb377696c0a98a56f9ea11d0116b28399c8f6 100644
+--- a/src/main/java/net/minecraft/world/level/biome/BiomeManager.java
++++ b/src/main/java/net/minecraft/world/level/biome/BiomeManager.java
+@@ -9,6 +9,8 @@ import net.minecraft.util.Mth;
+ 
+ public class BiomeManager {
+     public static final int CHUNK_CENTER_QUART = QuartPos.fromBlock(8);
++    public static boolean PLAZMA_CARPET_FIXES = false; // Plazma - Implement CarpetFixes
++    private static final double MAX_OFFSET = 0.450_000_000_1; // Plazma - Implement CarpetFixes
+     private static final int ZOOM_BITS = 2;
+     private static final int ZOOM = 4;
+     private static final int ZOOM_MASK = 3;
+@@ -29,6 +31,79 @@ public class BiomeManager {
+     }
+ 
+     public Holder<Biome> getBiome(BlockPos pos) {
++        // Plazma start - Implement CarpetFixes
++        if (PLAZMA_CARPET_FIXES) {
++            final int x2 = pos.getX() - 2;
++            final int y2 = pos.getY() - 2;
++            final int z2 = pos.getZ() - 2;
++
++            final int x = x2 >> 2;
++            final int y = y2 >> 2;
++            final int z = z2 >> 2;
++
++            final double qX = (x2 & 3) / 4.0D;
++            final double qY = (y2 & 3) / 4.0D;
++            final double qZ = (z2 & 3) / 4.0D;
++
++            int minX = 0;
++            double minD = Double.POSITIVE_INFINITY;
++            for (int bX = 0; bX < 8; ++bX) {
++                final boolean x0 = (bX & 4) == 0;
++                final boolean y0 = (bX & 2) == 0;
++                final boolean z0 = (bX & 1) == 0;
++
++                final double x1 = x0 ? qX : qX - 1.0D;
++                final double y1 = y0 ? qY : qY - 1.0D;
++                final double z1 = z0 ? qZ : qZ - 1.0D;
++
++                double maxQY = 0.0D;
++                double maxQZ = 0.0D;
++                if (bX != 0) {
++                    final double maxQX = Mth.square(Math.max(x1 + MAX_OFFSET, Math.abs(x1 - MAX_OFFSET)));
++                    maxQY = Mth.square(Math.max(y1 + MAX_OFFSET, Math.abs(y1 - MAX_OFFSET)));
++                    maxQZ = Mth.square(Math.max(z1 + MAX_OFFSET, Math.abs(z1 - MAX_OFFSET)));
++
++                    if (minD < maxQY + maxQZ + maxQX) continue;
++                }
++
++                int pX = x0 ? x : x + 1;
++                int pY = y0 ? y : y + 1;
++                int pZ = z0 ? z : z + 1;
++
++                long seed = this.biomeZoomSeed;
++                seed = LinearCongruentialGenerator.next(seed, pX);
++                seed = LinearCongruentialGenerator.next(seed, pY);
++                seed = LinearCongruentialGenerator.next(seed, pZ);
++                seed = LinearCongruentialGenerator.next(seed, pX);
++                seed = LinearCongruentialGenerator.next(seed, pY);
++                seed = LinearCongruentialGenerator.next(seed, pZ);
++
++                double dX = getFiddle(seed);
++                double sX = Mth.square(x1 + dX);
++                if (bX != 0 && minD < sX + maxQY + maxQZ) continue;
++
++                seed = LinearCongruentialGenerator.next(seed, this.biomeZoomSeed);
++                double dY = getFiddle(seed);
++                double sY = Mth.square(y1 + dY);
++                if (bX != 0 && minD < sX + sY + maxQZ) continue;
++
++                seed = LinearCongruentialGenerator.next(seed, this.biomeZoomSeed);
++                double dZ = getFiddle(seed);
++                double bD = sX + sY + Mth.square(z1 + dZ);
++
++                if (minD <= bD) continue;
++                minX = bX;
++                minD = bD;
++            }
++
++            return this.noiseBiomeSource.getNoiseBiome(
++                (minX & 4) == 0 ? x : x + 1,
++                (minX & 2) == 0 ? y : y + 1,
++                (minX & 1) == 0 ? z : z + 1
++            );
++        }
++        // Plazma end - Implement CarpetFixes
++
+         int i = pos.getX() - 2;
+         int j = pos.getY() - 2;
+         int k = pos.getZ() - 2;
+diff --git a/src/main/java/org/plazmamc/plazma/configurations/GlobalConfiguration.java b/src/main/java/org/plazmamc/plazma/configurations/GlobalConfiguration.java
+index 538c572661bd92666f84e6f9ef3e9760f69f50a9..db31d0c066e92fe308e7e64075e832bec66a5c02 100644
+--- a/src/main/java/org/plazmamc/plazma/configurations/GlobalConfiguration.java
++++ b/src/main/java/org/plazmamc/plazma/configurations/GlobalConfiguration.java
+@@ -188,4 +188,16 @@ public class GlobalConfiguration extends ConfigurationPart {
+ 
+     }
+ 
++    public CarpetFixes carpetFixes;
++    public class CarpetFixes extends ConfigurationPart {
++
++        boolean optimizeBiomeAccess = OPTIMIZE;
++
++        @PostProcess
++        void post() {
++            net.minecraft.world.level.biome.BiomeManager.PLAZMA_CARPET_FIXES = this.optimizeBiomeAccess;
++        }
++
++    }
++
+ }
+diff --git a/src/main/java/org/plazmamc/plazma/configurations/WorldConfigurations.java b/src/main/java/org/plazmamc/plazma/configurations/WorldConfigurations.java
+index 36345efa302413ad4e7d6e611d182572622f76ff..d314be46a02d73e669088d3a37937c8751f7735d 100644
+--- a/src/main/java/org/plazmamc/plazma/configurations/WorldConfigurations.java
++++ b/src/main/java/org/plazmamc/plazma/configurations/WorldConfigurations.java
+@@ -126,4 +126,11 @@ public class WorldConfigurations extends ConfigurationPart {
+ 
+     }
+ 
++    public CarpetFixes carpetFixes;
++    public class CarpetFixes extends ConfigurationPart {
++
++        public boolean preparedSheepChildColor = OPTIMIZE;
++
++    }
++
+ }
+diff --git a/src/main/java/org/plazmamc/plazma/util/CarpetFixes.java b/src/main/java/org/plazmamc/plazma/util/CarpetFixes.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..a5b0ce75a0ffa65e357cde2d55b7a0f116a2afad
+--- /dev/null
++++ b/src/main/java/org/plazmamc/plazma/util/CarpetFixes.java
+@@ -0,0 +1,45 @@
++package org.plazmamc.plazma.util;
++
++import net.minecraft.world.item.DyeColor;
++
++public interface CarpetFixes {
++
++    static DyeColor properDyeMixin(DyeColor firstColor, DyeColor secondColor) {
++        if (firstColor.equals(secondColor)) return firstColor;
++
++        return switch (firstColor) {
++            case WHITE -> switch (secondColor) {
++                case BLUE -> DyeColor.LIGHT_BLUE;
++                case GRAY -> DyeColor.LIGHT_GRAY;
++                case BLACK -> DyeColor.GRAY;
++                case GREEN -> DyeColor.LIME;
++                case RED -> DyeColor.PINK;
++                default -> null;
++            };
++            case BLUE -> switch (secondColor) {
++                case WHITE -> DyeColor.LIGHT_BLUE;
++                case GREEN -> DyeColor.CYAN;
++                case RED -> DyeColor.PURPLE;
++                default -> null;
++            };
++            case RED -> switch (secondColor) {
++                case YELLOW -> DyeColor.ORANGE;
++                case WHITE -> DyeColor.PINK;
++                case BLUE -> DyeColor.PURPLE;
++                default -> null;
++            };
++            case GREEN -> switch (secondColor) {
++                case BLUE -> DyeColor.CYAN;
++                case WHITE -> DyeColor.LIME;
++                default -> null;
++            };
++            case YELLOW -> secondColor.equals(DyeColor.RED) ? DyeColor.ORANGE : null;
++            case PURPLE -> secondColor.equals(DyeColor.PINK) ? DyeColor.MAGENTA : null;
++            case PINK -> secondColor.equals(DyeColor.PURPLE) ? DyeColor.MAGENTA : null;
++            case GRAY -> secondColor.equals(DyeColor.WHITE) ? DyeColor.LIGHT_GRAY : null;
++            case BLACK -> secondColor.equals(DyeColor.WHITE) ? DyeColor.GRAY : null;
++            default -> null;
++        };
++    }
++
++}

patches/server/features/sparklypaper/unapplied/0012-Revert-Fix-MC-117075-Block-entity-unload-lag-spike.patch

@@ -0,0 +1,37 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrPowerGamerBR <git@mrpowergamerbr.com>
+Date: Sun, 18 Feb 2024 14:22:37 -0300
+Subject: [PATCH] Revert "Fix MC-117075: Block entity unload lag spike"
+
+This reverts commit f3453b204569ea865cc1d1302edb6d125e7f0cb3.
+
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 8433caa61a973d81a5eedc44428926e999c21a03..db9eb10c33848ca5b342bf00e4a05738210d26b0 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
++++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -1458,8 +1458,6 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+         int tickedEntities = 0; // Paper - rewrite chunk system
+ 
+         int tilesThisCycle = 0;
+-        var toRemove = new it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet<TickingBlockEntity>(); // Paper - Fix MC-117075; use removeAll
+-        toRemove.add(null); // Paper - Fix MC-117075
+         for (tileTickPosition = 0; tileTickPosition < this.blockEntityTickers.size(); tileTickPosition++) { // Paper - Disable tick limiters
+             this.tileTickPosition = (this.tileTickPosition < this.blockEntityTickers.size()) ? this.tileTickPosition : 0;
+             TickingBlockEntity tickingblockentity = (TickingBlockEntity) this.blockEntityTickers.get(this.tileTickPosition);
+@@ -1468,7 +1466,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+             if (tickingblockentity.isRemoved()) {
+                 // Spigot start
+                 tilesThisCycle--;
+-                toRemove.add(tickingblockentity); // Paper - Fix MC-117075; use removeAll
++                this.blockEntityTickers.remove(this.tileTickPosition--);
+                 // Spigot end
+             } else if (flag && this.shouldTickBlocksAt(tickingblockentity.getPos())) {
+                 tickingblockentity.tick();
+@@ -1479,7 +1477,6 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+                 // Paper end - rewrite chunk system
+             }
+         }
+-        this.blockEntityTickers.removeAll(toRemove); // Paper - Fix MC-117075
+ 
+         this.tickingBlockEntities = false;
+         gameprofilerfiller.pop();

patches/server/features/sparklypaper/unapplied/0014-Optimize-tickBlockEntities.patch

@@ -0,0 +1,123 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrPowerGamerBR <git@mrpowergamerbr.com>
+Date: Sun, 26 Nov 2023 13:11:10 -0300
+Subject: [PATCH] Optimize tickBlockEntities
+
+We cache the last `shouldTickBlocksAt` result, because the `shouldTickBlocksAt` is expensive because it requires pulling chunk holder info from an map for each block entity (even if the block entities are on the same chunk!) every single time. So, if the last chunk position is the same as our cached value, we use the last cached `shouldTickBlocksAt` result!
+
+We could use a map for caching, but here's why this is way better than using a map: The block entity ticking list is sorted by chunks! Well, sort of... It is sorted by chunk when the chunk has been loaded, newly placed blocks will be appended to the end of the list until the chunk unloads and loads again.  Most block entities are things that players placed to be there for a long time anyway (like hoppers, etc)
+
+But here's the thing: We don't care if we have a small performance penalty if the players have placed new block entities, the small performance hit of when a player placed new block entities is so small ('tis just a long comparsion after all), that the performance boost from already placed block entities is bigger, this helps a lot if your server has a lot of chunks with multiple block entities, and the block entities will be automatically sorted after the chunk is unloaded and loaded again, so it ain't that bad.
+
+And finally, we also cache the chunk's coordinate key when creating the block entity, which is actually "free" because we just reuse the already cached chunk coordinate key from the chunk!
+
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 1e20c525cd0c75079fe971ae830120c69fee362e..97b31dffbaf965e86ad706a1bba7586cd3514ead 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
++++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -1458,6 +1458,10 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+         int tickedEntities = 0; // Paper - rewrite chunk system
+ 
+         int tilesThisCycle = 0;
++        // SparklyPaper start - optimize tickBlockEntities
++        int shouldTickBlocksAtLastResult = -1; // -1 = undefined
++        long shouldTickBlocksAtChunkPos = 0L;
++        // SparklyPaper end
+         for (tileTickPosition = 0; tileTickPosition < this.blockEntityTickers.size(); tileTickPosition++) { // Paper - Disable tick limiters
+             this.tileTickPosition = (this.tileTickPosition < this.blockEntityTickers.size()) ? this.tileTickPosition : 0;
+             TickingBlockEntity tickingblockentity = (TickingBlockEntity) this.blockEntityTickers.get(this.tileTickPosition);
+@@ -1468,13 +1472,25 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+                 tilesThisCycle--;
+                 this.blockEntityTickers.markAsRemoved(this.tileTickPosition); // this.blockEntityTickers.remove(this.tileTickPosition--); // SparklyPaper - optimize block entity removals
+                 // Spigot end
+-            } else if (flag && this.shouldTickBlocksAt(tickingblockentity.getPos())) {
++                // } else if (flag && this.shouldTickBlocksAt(tickingblockentity.getPos())) { // SparklyPaper start - optimize tickBlockEntities
++            } else if (flag) {
++                long chunkPos = tickingblockentity.getChunkCoordinateKey();
++                boolean shouldTick;
++                if (shouldTickBlocksAtChunkPos == chunkPos && shouldTickBlocksAtLastResult != -1) {
++                    shouldTick = shouldTickBlocksAtLastResult == 1;
++                } else {
++                    shouldTick = this.shouldTickBlocksAt(chunkPos);
++                    shouldTickBlocksAtLastResult = shouldTick ? 1 : 0;
++                    shouldTickBlocksAtChunkPos = chunkPos;
++                }
++                if (shouldTick) {
+                 tickingblockentity.tick();
+                 // Paper start - rewrite chunk system
+                 if ((++tickedEntities & 7) == 0) {
+                     ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemLevel)(Level)(Object)this).moonrise$midTickTasks();
+                 }
+                 // Paper end - rewrite chunk system
++                } // SparklyPaper end
+             }
+         }
+         this.blockEntityTickers.removeMarkedEntries(); // SparklyPaper - optimize block entity removals
+diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+index 4640baec5bed6c2d53cc0f8ca1d273cc115abe9b..b4c16fe7c9215b5610b7e7488c29b497b5357ecc 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
++++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+@@ -75,6 +75,13 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p
+         public String getType() {
+             return "<null>";
+         }
++
++        // SparklyPaper start - optimize tickBlockEntities
++        @Override
++        public long getChunkCoordinateKey() {
++            return 0;
++        }
++        // SparklyPaper end
+     };
+     private final Map<BlockPos, LevelChunk.RebindableTickingBlockEntityWrapper> tickersInLevel;
+     public boolean loaded;
+@@ -981,7 +988,7 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p
+     }
+ 
+     private <T extends BlockEntity> TickingBlockEntity createTicker(T blockEntity, BlockEntityTicker<T> blockEntityTicker) {
+-        return new LevelChunk.BoundTickingBlockEntity<>(blockEntity, blockEntityTicker);
++        return new LevelChunk.BoundTickingBlockEntity<>(blockEntity, blockEntityTicker, this.coordinateKey); // SparklyPaper - optimize tickBlockEntities
+     }
+ 
+     @FunctionalInterface
+@@ -1038,6 +1045,13 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p
+         public String toString() {
+             return String.valueOf(this.ticker) + " <wrapped>";
+         }
++
++        // SparklyPaper start - optimize tickBlockEntities
++        @Override
++        public long getChunkCoordinateKey() {
++            return this.ticker.getChunkCoordinateKey();
++        }
++        // SparklyPaper end
+     }
+ 
+     private class BoundTickingBlockEntity<T extends BlockEntity> implements TickingBlockEntity {
+@@ -1045,10 +1059,12 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p
+         private final T blockEntity;
+         private final BlockEntityTicker<T> ticker;
+         private boolean loggedInvalidBlockState;
++        private final long chunkCoordinateKey; // SparklyPaper - optimize tickBlockEntities
+ 
+-        BoundTickingBlockEntity(final BlockEntity tileentity, final BlockEntityTicker blockentityticker) {
++        BoundTickingBlockEntity(final BlockEntity tileentity, final BlockEntityTicker blockentityticker, long chunkCoordinateKey) { // SparklyPaper - optimize tickBlockEntities
+             this.blockEntity = (T) tileentity; // CraftBukkit - decompile error
+             this.ticker = blockentityticker;
++            this.chunkCoordinateKey = chunkCoordinateKey; // SparklyPaper - optimize tickBlockEntities
+         }
+ 
+         @Override
+@@ -1112,5 +1128,12 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p
+ 
+             return "Level ticker for " + s + "@" + String.valueOf(this.getPos());
+         }
++
++        // SparklyPaper start - optimize tickBlockEntities
++        @Override
++        public long getChunkCoordinateKey() {
++            return this.chunkCoordinateKey;
++        }
++        // SparklyPaper end
+     }
+ }

patches/server/features/sparklypaper/unapplied/0018-Helpful-NMS-packet-changes.patch

@@ -0,0 +1,144 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrPowerGamerBR <git@mrpowergamerbr.com>
+Date: Mon, 10 Jun 2024 13:06:30 -0300
+Subject: [PATCH] Helpful NMS packet changes
+
+Some nice changes to the packet internals to make packet sending and manipulation easier for us to avoid Reflection and JVM internals (ooo theUnsafe spooky) usage
+
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundAddEntityPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundAddEntityPacket.java
+index f66e40326c510aa3267542b1a24ed75d1ed6d3f1..797640c4f26abb32a480a611820bbcd72e43d1ac 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundAddEntityPacket.java
++++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundAddEntityPacket.java
+@@ -22,7 +22,7 @@ public class ClientboundAddEntityPacket implements Packet<ClientGamePacketListen
+     private static final double LIMIT = 3.9;
+     private final int id;
+     private final UUID uuid;
+-    private final EntityType<?> type;
++    public EntityType<?> type; // SparklyPaper - Helpful NMS packet changes: remove final and make public
+     private final double x;
+     private final double y;
+     private final double z;
+@@ -180,6 +180,32 @@ public class ClientboundAddEntityPacket implements Packet<ClientGamePacketListen
+         return Mth.unpackDegrees(this.yHeadRot);
+     }
+ 
++    // SparklyPaper - Helpful NMS packet changes: expose raw rotational fields
++    public int getXaRaw() {
++        return this.xa;
++    }
++
++    public int getYaRaw() {
++        return this.ya;
++    }
++
++    public int getZaRaw() {
++        return this.za;
++    }
++
++    public byte getXRotRaw() {
++        return this.xRot;
++    }
++
++    public byte getYRotRaw() {
++        return this.yRot;
++    }
++
++    public byte getYHeadRotRaw() {
++        return this.yHeadRot;
++    }
++    // SparklyPaper end
++
+     public int getData() {
+         return this.data;
+     }
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundBlockUpdatePacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundBlockUpdatePacket.java
+index 1e8fad30c5f5be48501c7d8584caedcdc232f6c8..772848cf83a92a8ef8d734949b21f2f1d13e3fcb 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundBlockUpdatePacket.java
++++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundBlockUpdatePacket.java
+@@ -19,7 +19,7 @@ public class ClientboundBlockUpdatePacket implements Packet<ClientGamePacketList
+         ClientboundBlockUpdatePacket::new
+     );
+     private final BlockPos pos;
+-    public final BlockState blockState;
++    public BlockState blockState; // SparklyPaper - Helpful NMS packet changes: remove final
+ 
+     public ClientboundBlockUpdatePacket(BlockPos pos, BlockState state) {
+         this.pos = pos;
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
+index 0a8d07bf68b0ceabd13c70196d357fce79dcc2c3..0b5abaf11508fa6c6809b73f53d6854aa3b3247c 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
++++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
+@@ -25,7 +25,7 @@ import net.minecraft.world.level.levelgen.Heightmap;
+ public class ClientboundLevelChunkPacketData {
+     private static final int TWO_MEGABYTES = 2097152;
+     private final CompoundTag heightmaps;
+-    private final byte[] buffer;
++    public byte[] buffer; // SparklyPaper - Helpful NMS packet changes: remove final and make public
+     private final List<ClientboundLevelChunkPacketData.BlockEntityInfo> blockEntitiesData;
+     // Paper start - Handle oversized block entities in chunks
+     private final java.util.List<net.minecraft.network.protocol.Packet<?>> extraPackets = new java.util.ArrayList<>();
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundRotateHeadPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundRotateHeadPacket.java
+index ab44c24ce5f4570dee9d84b4216299bedfa800d8..99fbb958b82a3398564febb1e87e3ef4efca5b1a 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundRotateHeadPacket.java
++++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundRotateHeadPacket.java
+@@ -20,6 +20,13 @@ public class ClientboundRotateHeadPacket implements Packet<ClientGamePacketListe
+         this.yHeadRot = headYaw;
+     }
+ 
++    // SparklyPaper start - Helpful NMS packet changes: add entity ID constructor
++    public ClientboundRotateHeadPacket(int entityId, byte headYaw) {
++        this.entityId = entityId;
++        this.yHeadRot = headYaw;
++    }
++    // SparklyPaper end
++
+     private ClientboundRotateHeadPacket(FriendlyByteBuf buf) {
+         this.entityId = buf.readVarInt();
+         this.yHeadRot = buf.readByte();
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundSectionBlocksUpdatePacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundSectionBlocksUpdatePacket.java
+index 1a37654aff9a9c86c9f7af10a1cf721371f0c5ec..e69ff4e6bb3919340a93ed4c68bdd6c4778669a9 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundSectionBlocksUpdatePacket.java
++++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundSectionBlocksUpdatePacket.java
+@@ -17,9 +17,9 @@ public class ClientboundSectionBlocksUpdatePacket implements Packet<ClientGamePa
+ 
+     public static final StreamCodec<FriendlyByteBuf, ClientboundSectionBlocksUpdatePacket> STREAM_CODEC = Packet.codec(ClientboundSectionBlocksUpdatePacket::write, ClientboundSectionBlocksUpdatePacket::new);
+     private static final int POS_IN_SECTION_BITS = 12;
+-    private final SectionPos sectionPos;
+-    private final short[] positions;
+-    private final BlockState[] states;
++    public SectionPos sectionPos; // SparklyPaper - Helpful NMS packet changes: remove final and make public
++    public short[] positions; // SparklyPaper - Helpful NMS packet changes: remove final and make public
++    public BlockState[] states; // SparklyPaper - Helpful NMS packet changes: remove final and make public
+ 
+     public ClientboundSectionBlocksUpdatePacket(SectionPos sectionPos, ShortSet positions, LevelChunkSection section) {
+         this.sectionPos = sectionPos;
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetCameraPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetCameraPacket.java
+index 799f5a8c69f295216997d52fb4bc6c56d3a18115..633f10f17eebd43e8dc7c878b9101decf31190a9 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetCameraPacket.java
++++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetCameraPacket.java
+@@ -18,6 +18,12 @@ public class ClientboundSetCameraPacket implements Packet<ClientGamePacketListen
+         this.cameraId = entity.getId();
+     }
+ 
++    // SparklyPaper - Helpful NMS packet changes: add direct entityId constructor
++    public ClientboundSetCameraPacket(int entityId) {
++        this.cameraId = entityId;
++    }
++    // SparklyPaper end
++
+     private ClientboundSetCameraPacket(FriendlyByteBuf buf) {
+         this.cameraId = buf.readVarInt();
+     }
+diff --git a/src/main/java/net/minecraft/world/entity/Display.java b/src/main/java/net/minecraft/world/entity/Display.java
+index e6cbf4506c75046a89fad778e138b448fb4a29a9..3b705c75b840dbb0e741f46aaa3b98180a27ecf5 100644
+--- a/src/main/java/net/minecraft/world/entity/Display.java
++++ b/src/main/java/net/minecraft/world/entity/Display.java
+@@ -802,7 +802,7 @@ public abstract class Display extends Entity {
+         public static final byte FLAG_ALIGN_RIGHT = 16;
+         private static final byte INITIAL_TEXT_OPACITY = -1;
+         public static final int INITIAL_BACKGROUND = 1073741824;
+-        private static final EntityDataAccessor<Component> DATA_TEXT_ID = SynchedEntityData.defineId(Display.TextDisplay.class, EntityDataSerializers.COMPONENT);
++        public static final EntityDataAccessor<Component> DATA_TEXT_ID = SynchedEntityData.defineId(Display.TextDisplay.class, EntityDataSerializers.COMPONENT); // SparklyPaper - Helpful NMS packet changes: make public
+         public static final EntityDataAccessor<Integer> DATA_LINE_WIDTH_ID = SynchedEntityData.defineId(Display.TextDisplay.class, EntityDataSerializers.INT);
+         public static final EntityDataAccessor<Integer> DATA_BACKGROUND_COLOR_ID = SynchedEntityData.defineId(
+             Display.TextDisplay.class, EntityDataSerializers.INT

patches/server/features/sparklypaper/unapplied/removed/0003-Optimize-entity-coordinate-key.patch

@@ -0,0 +1,38 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Kevin Raneri <kevin.raneri@gmail.com>
+Date: Tue, 9 Nov 2021 14:33:16 -0500
+Subject: [PATCH] Optimize entity coordinate key
+
+When executing getCoordinateKey for entities (a hotpath), the JVM is
+required to repeatedly cast doubles to longs. The performance impact of
+this depends on the CPU architecture, but generally switching between
+FPU and ALU incurs a significant performance hit. The casted/rounded
+data is already available in the blockPosition struct, so we use that
+instead of re-doing the casting.
+
+diff --git a/src/main/java/io/papermc/paper/util/MCUtil.java b/src/main/java/io/papermc/paper/util/MCUtil.java
+index 1d6b3fe2ce240af4ede61588795456b046eee6c9..cdcb1bff7913bfe86fed008271016a3175b6df90 100644
+--- a/src/main/java/io/papermc/paper/util/MCUtil.java
++++ b/src/main/java/io/papermc/paper/util/MCUtil.java
+@@ -215,7 +215,7 @@ public final class MCUtil {
+     }
+ 
+     public static long getCoordinateKey(final Entity entity) {
+-        return ((long)(MCUtil.fastFloor(entity.getZ()) >> 4) << 32) | ((MCUtil.fastFloor(entity.getX()) >> 4) & 0xFFFFFFFFL);
++        return ((long)(entity.blockPosition.getZ() >> 4) << 32) | ((entity.blockPosition.getX() >> 4) & 0xFFFFFFFFL); // Pufferfish - eliminate double->long cast in hotpath
+     }
+ 
+     public static long getCoordinateKey(final ChunkPos pair) {
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 4ee843dfd826772c9157ca421d8fe1f36f814b51..41ce41e92f3722e7ffb3423c90663d7a677bf277 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -311,7 +311,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     public double yo;
+     public double zo;
+     private Vec3 position;
+-    private BlockPos blockPosition;
++    public BlockPos blockPosition; // Pufferfish - private->public
+     private ChunkPos chunkPosition;
+     private Vec3 deltaMovement;
+     private float yRot;

patches/server/features/sparklypaper/unapplied/removed/0009-Avoid-unnecessary-ItemFrame-getItem-calls.patch

@@ -0,0 +1,55 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrPowerGamerBR <git@mrpowergamerbr.com>
+Date: Sat, 18 Nov 2023 21:04:53 -0300
+Subject: [PATCH] Avoid unnecessary ItemFrame#getItem() calls
+
+When ticking a item frame, on each tick, it checks if the item on the item frame is a map and, if it is, it adds the map to be carried by the entity player
+
+However, the "getItem()" call is a bit expensive, especially because this is only really used if the item in the item frame is a map
+
+We can avoid this call by checking if the "cachedMapId" is not null
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
+index aedf24ba0d64de855a59869052cbc2704e7dc134..f49585cfd485eed504e91887599ff25c3238c8fd 100644
+--- a/src/main/java/net/minecraft/server/level/ServerEntity.java
++++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
+@@ -115,13 +115,14 @@ public class ServerEntity {
+             ItemFrame entityitemframe = (ItemFrame) entity;
+ 
+             if (true || this.tickCount % 10 == 0) { // CraftBukkit - Moved below, should always enter this block
+-                ItemStack itemstack = entityitemframe.getItem();
+-
+-                if (this.level.paperConfig().maps.itemFrameCursorUpdateInterval > 0 && this.tickCount % this.level.paperConfig().maps.itemFrameCursorUpdateInterval == 0 && itemstack.getItem() instanceof MapItem) { // CraftBukkit - Moved this.tickCounter % 10 logic here so item frames do not enter the other blocks // Paper - Make item frame map cursor update interval configurable
++                if (this.level.paperConfig().maps.itemFrameCursorUpdateInterval > 0 && this.tickCount % this.level.paperConfig().maps.itemFrameCursorUpdateInterval == 0 && entityitemframe.cachedMapId != null) { // CraftBukkit - Moved this.tickCounter % 10 logic here so item frames do not enter the other blocks // Paper - Make item frame map cursor update interval configurable // SparklyPaper - avoid unnecessary ItemFrame#getItem() calls
+                     Integer integer = entityitemframe.cachedMapId; // Paper
+                     MapItemSavedData worldmap = MapItem.getSavedData(integer, this.level);
+ 
+                     if (worldmap != null) {
++                        // SparklyPaper start - avoid unnecessary ItemFrame#getItem() calls
++                        ItemStack itemstack = entityitemframe.getItem();
++                        if (itemstack.getItem() instanceof MapItem) { // fail-safe, what if the cached map ID is present but the item isn't a MapItem? (this should NEVER happen but, who knows)
+                         Iterator<ServerPlayerConnection> iterator = this.trackedPlayers.iterator(); // CraftBukkit
+ 
+                         while (iterator.hasNext()) {
+@@ -134,6 +135,7 @@ public class ServerEntity {
+                                 entityplayer.connection.send(packet);
+                             }
+                         }
++                        } // SparklyPaper end
+                     }
+                 }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+index 759ecd79534a7706f7d4a63eb9dacbefcfe54674..07739c3d74074b2668466250f944dfbe22d4dc86 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
++++ b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+@@ -50,7 +50,8 @@ public class ItemFrame extends HangingEntity {
+     public static final int NUM_ROTATIONS = 8;
+     public float dropChance;
+     public boolean fixed;
+-    public Integer cachedMapId; // Paper
++    @Nullable // SparklyPaper - avoid unnecessary ItemFrame#getItem() calls
++    public Integer cachedMapId = null; // Paper // SparklyPaper - avoid unnecessary ItemFrame#getItem() calls
+ 
+     public ItemFrame(EntityType<? extends ItemFrame> type, Level world) {
+         super(type, world);

patches/server/features/sparklypaper/unapplied/removed/0016-Only-check-thundering-once-per-world-instead-for-eve.patch

@@ -0,0 +1,44 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrPowerGamerBR <git@mrpowergamerbr.com>
+Date: Sun, 22 Oct 2023 12:27:26 -0300
+Subject: [PATCH] Only check thundering once per world instead for every chunk
+
+For some reason the isThundering check is consuming ~3% of CPU time when profiled so, instead of checking the thunder every chunk, we can cache the result and reuse on the same chunk tick
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+index c02ffd419236980cd063741612e99d739d97ec94..daa5948cc7b86a719a313ea595f135cd00b6a3cc 100644
+--- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
++++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+@@ -599,6 +599,7 @@ public class ServerChunkCache extends ChunkSource {
+             }
+             // Paper end - optimise chunk tick iteration
+ 
++            this.level.isCurrentlyThundering = this.level.isThundering_old(); // SparklyPaper - Only check thundering once per world instead for every chunk
+             int chunksTicked = 0; // Paper
+             // Paper start - optimise chunk tick iteration
+             io.papermc.paper.util.player.NearbyPlayers nearbyPlayers = this.chunkMap.getNearbyPlayers(); // Paper - optimise chunk tick iteration
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 9388dd9b34bb8148ce8b5f7e24122fa4bd1bafa8..0210226d2185803a18c0020d7985c1fccb798953 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
++++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -184,6 +184,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+     private int tileTickPosition;
+     public final Map<Explosion.CacheKey, Float> explosionDensityCache = new HashMap<>(); // Paper - Optimize explosions
+     public java.util.ArrayDeque<net.minecraft.world.level.block.RedstoneTorchBlock.Toggle> redstoneUpdateInfos; // Paper - Move from Map in BlockRedstoneTorch to here
++    public boolean isCurrentlyThundering; // SparklyPaper - Only check if the world is currently thundering once instead for every chunk
+ 
+     // Paper start - fix and optimise world upgrading
+     // copied from below
+@@ -1614,7 +1615,12 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+         this.rainLevel = f1;
+     }
+ 
++    // SparklyPaper start - Only check thundering once per world instead for every chunk
+     public boolean isThundering() {
++        return isCurrentlyThundering;
++    }
++    public boolean isThundering_old() {
++        // SparklyPaper end
+         return this.dimensionType().hasSkyLight() && !this.dimensionType().hasCeiling() ? (double) this.getThunderLevel(1.0F) > 0.9D : false;
+     }
+ 

patches/server/features/sparklypaper/unapplied/removed/0017-Optimize-heavy-EntityLookup.ArrayIterable.-init-call.patch

@@ -0,0 +1,106 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrPowerGamerBR <git@mrpowergamerbr.com>
+Date: Sat, 28 Oct 2023 19:02:12 -0300
+Subject: [PATCH] Optimize heavy EntityLookup.ArrayIterable.<init>() calls on
+ tickChunks
+
+For some reason, on SparklyPower allocating an ArrayIterable is expensive, taking around ~2.5% of tick time (I have no idea why tho), because tickChunks() only uses this for the NaturalSpawner, let's avoid the array allocation by passing thru the raw array data + size
+
+diff --git a/src/main/java/io/papermc/paper/chunk/system/entity/EntityLookup.java b/src/main/java/io/papermc/paper/chunk/system/entity/EntityLookup.java
+index 15ee41452992714108efe53b708b5a4e1da7c1ff..f5a5796dda9e0e05ed9afc069c241dedd9aaffa0 100644
+--- a/src/main/java/io/papermc/paper/chunk/system/entity/EntityLookup.java
++++ b/src/main/java/io/papermc/paper/chunk/system/entity/EntityLookup.java
+@@ -198,6 +198,12 @@ public final class EntityLookup implements LevelEntityGetter<Entity> {
+         return Arrays.copyOf(this.accessibleEntities.getRawData(), this.accessibleEntities.size(), Entity[].class);
+     }
+ 
++    // SparklyPaper start - Optimize heavy EntityLookup$ArrayIterable.<init>() calls on tickChunks
++    public EntityList getAccessibleEntities() {
++        return this.accessibleEntities;
++    }
++    // SparklyPaper end
++
+     @Override
+     public <U extends Entity> void get(final EntityTypeTest<Entity, U> filter, final AbortableIterationConsumer<U> action) {
+         final Int2ReferenceOpenHashMap<Entity> entityCopy;
+diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+index f8270b78ab0d561e55301e989d80fe7b4118337a..e51d06140153e7f9a6e41b20addf02ec94e0f72c 100644
+--- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
++++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+@@ -545,9 +545,9 @@ public class ServerChunkCache extends ChunkSource {
+                     }
+                     // Paper end - per player mob spawning backoff
+                 }
+-                spawnercreature_d = NaturalSpawner.createState(l, this.level.getAllEntities(), this::getFullChunk, null, true);
++                spawnercreature_d = NaturalSpawner.createState(l, this.level.getEntityLookup().getAccessibleEntities().getRawData(), this.level.getEntityLookup().getAccessibleEntities().size(), this::getFullChunk, null, true); // SparklyPaper - Optimize heavy EntityLookup$ArrayIterable.<init>() calls on tickChunks
+             } else {
+-                spawnercreature_d = NaturalSpawner.createState(l, this.level.getAllEntities(), this::getFullChunk, !this.level.paperConfig().entities.spawning.perPlayerMobSpawns ? new LocalMobCapCalculator(this.chunkMap) : null, false);
++                spawnercreature_d = NaturalSpawner.createState(l, this.level.getEntityLookup().getAccessibleEntities().getRawData(), this.level.getEntityLookup().getAccessibleEntities().size(), this::getFullChunk, !this.level.paperConfig().entities.spawning.perPlayerMobSpawns ? new LocalMobCapCalculator(this.chunkMap) : null, false); // SparklyPaper - Optimize heavy EntityLookup$ArrayIterable.<init>() calls on tickChunks
+             }
+             // Paper end
+             this.level.timings.countNaturalMobs.stopTiming(); // Paper - timings
+diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+index 9c2d62feff1816f5729060c6192269a5b2d34153..78bcb0af0735fe0ccf68ed06d8dc78d6e8c37064 100644
+--- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java
++++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+@@ -74,7 +74,60 @@ public final class NaturalSpawner {
+         return createState(spawningChunkCount, entities, chunkSource, densityCapper, false);
+     }
+ 
++    // SparklyPaper start - Optimize heavy EntityLookup$ArrayIterable.<init>() calls on tickChunks
++    public static NaturalSpawner.SpawnState createState(int spawningChunkCount, Entity[] entities, int count, NaturalSpawner.ChunkGetter chunkSource, LocalMobCapCalculator densityCapper, boolean countMobs) {
++        PotentialCalculator spawnercreatureprobabilities = new PotentialCalculator();
++        Object2IntOpenHashMap<MobCategory> object2intopenhashmap = new Object2IntOpenHashMap();
++
++        for (int index = 0; count > index; index++) {
++            Entity entity = entities[index];
++
++            if (entity instanceof Mob) {
++                Mob entityinsentient = (Mob) entity;
++
++                if (entityinsentient.isPersistenceRequired() || entityinsentient.requiresCustomPersistence()) {
++                    continue;
++                }
++            }
++
++            MobCategory enumcreaturetype = entity.getType().getCategory();
++
++            if (enumcreaturetype != MobCategory.MISC) {
++                // Paper start - Only count natural spawns
++                if (!entity.level().paperConfig().entities.spawning.countAllMobsForSpawning &&
++                    !(entity.spawnReason == org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL ||
++                        entity.spawnReason == org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.CHUNK_GEN)) {
++                    continue;
++                }
++                // Paper end
++                BlockPos blockposition = entity.blockPosition();
++
++                chunkSource.query(ChunkPos.asLong(blockposition), (chunk) -> {
++                    MobSpawnSettings.MobSpawnCost biomesettingsmobs_b = NaturalSpawner.getRoughBiome(blockposition, chunk).getMobSettings().getMobSpawnCost(entity.getType());
++
++                    if (biomesettingsmobs_b != null) {
++                        spawnercreatureprobabilities.addCharge(entity.blockPosition(), biomesettingsmobs_b.charge());
++                    }
++
++                    if (densityCapper != null && entity instanceof Mob) { // Paper
++                        densityCapper.addMob(chunk.getPos(), enumcreaturetype);
++                    }
++
++                    object2intopenhashmap.addTo(enumcreaturetype, 1);
++                    // Paper start
++                    if (countMobs) {
++                        chunk.level.getChunkSource().chunkMap.updatePlayerMobTypeMap(entity);
++                    }
++                    // Paper end
++                });
++            }
++        }
++
++        return new NaturalSpawner.SpawnState(spawningChunkCount, object2intopenhashmap, spawnercreatureprobabilities, densityCapper);
++    }
++
+     public static NaturalSpawner.SpawnState createState(int spawningChunkCount, Iterable<Entity> entities, NaturalSpawner.ChunkGetter chunkSource, LocalMobCapCalculator densityCapper, boolean countMobs) {
++        // SparklyPaper end
+         // Paper end
+         PotentialCalculator spawnercreatureprobabilities = new PotentialCalculator();
+         Object2IntOpenHashMap<MobCategory> object2intopenhashmap = new Object2IntOpenHashMap();

patches/server/features/sparklypaper/unapplied/removed/0019-BlockEntityTickersList-optimization-tests.patch

@@ -0,0 +1,93 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrPowerGamerBR <git@mrpowergamerbr.com>
+Date: Fri, 24 Nov 2023 23:37:24 -0300
+Subject: [PATCH] BlockEntityTickersList optimization tests
+
+
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 94eac6837c06e6fd192c108632f1e365a008d6ad..3588657da9969b4207bbeb8109bc101384c03398 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
++++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -1274,8 +1274,8 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+         // Iterator iterator = this.blockEntityTickers.iterator();
+         int tilesThisCycle = 0;
+         // SparklyPaper start - optimize tickBlockEntities
+-        // var toRemove = new it.unimi.dsi.fastutil.objects.ObjectOpenCustomHashSet<TickingBlockEntity>(net.minecraft.Util.identityStrategy()); // Paper - use removeAll
+-        // toRemove.add(null);
++        var toRemoveOld = new it.unimi.dsi.fastutil.objects.ObjectOpenCustomHashSet<TickingBlockEntity>(net.minecraft.Util.identityStrategy()); // Paper - use removeAll
++        toRemoveOld.add(null);
+         var toRemove = new java.util.HashSet<Integer>(); // For some reason, Java's HashSet seems to be faster than fastutil's only if we are removing HUGE amounts of tile entities, idk why
+         var startSearchFromIndex = -1;
+         var shouldTickBlocksAtLastResult = -1; // -1 = undefined
+@@ -1301,13 +1301,13 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+                 // Spigot start
+                 tilesThisCycle--;
+                 // SparklyPaper start - optimize tickBlockEntities
+-                // toRemove.add(tickingblockentity); // Paper - use removeAll
++                toRemoveOld.add(tickingblockentity); // Paper - use removeAll
+                 toRemove.add(tileTickPosition);
+                 if (startSearchFromIndex == -1)
+                     startSearchFromIndex = tileTickPosition;
+                 // SparklyPaper end
+                 // Spigot end
+-            // } else if (this.shouldTickBlocksAt(tickingblockentity.getPos())) { // SparklyPaper start - optimize tickBlockEntities
++                // } else if (this.shouldTickBlocksAt(tickingblockentity.getPos())) { // SparklyPaper start - optimize tickBlockEntities
+             } else {
+                 long chunkPos = tickingblockentity.getChunkCoordinateKey();
+                 boolean shouldTick;
+@@ -1319,18 +1319,47 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+                     shouldTickBlocksAtChunkPos = chunkPos;
+                 }
+                 if (shouldTick) {
+-                tickingblockentity.tick();
+-                // Paper start - execute chunk tasks during tick
+-                if ((this.tileTickPosition & 7) == 0) {
+-                    // MinecraftServer.getServer().executeMidTickTasks(); // SparklyPaper - parallel world ticking (only run mid-tick at the end of each tick / fixes concurrency bugs related to executeMidTickTasks)
+-                }
+-                // Paper end - execute chunk tasks during tick
++                    tickingblockentity.tick();
++                    // Paper start - execute chunk tasks during tick
++                    if ((this.tileTickPosition & 7) == 0) {
++                        // MinecraftServer.getServer().executeMidTickTasks(); // SparklyPaper - parallel world ticking (only run mid-tick at the end of each tick / fixes concurrency bugs related to executeMidTickTasks)
++                    }
++                    // Paper end - execute chunk tasks during tick
+                 } // SparklyPaper end
+             }
+         }
+         // SparklyPaper start - optimize tickBlockEntities
+-        // this.blockEntityTickers.removeAll(toRemove);
+-        this.blockEntityTickers.removeAllByIndex(startSearchFromIndex, toRemove); // We don't need to care about if the startSearchFromIndex can be -1 here, since if it is -1, then the toRemove list is empty and the call will fast fail
++        java.util.ArrayList<TickingBlockEntity> oldList = new java.util.ArrayList<>(this.blockEntityTickers);
++        long diffOld = 0;
++        long diffNew = 0;
++        if (toRemoveOld.size() != 1) { // the old one always have null as the first element
++            var startOld = System.nanoTime();
++            oldList.removeAll(toRemoveOld);
++            var endOld = System.nanoTime();
++            diffOld = endOld - startOld;
++            System.out.println("Old version deleted " + toRemoveOld.size() + " elements, took " + diffOld + "ns");
++        }
++        if (startSearchFromIndex != -1) {
++            var start = System.nanoTime();
++            this.blockEntityTickers.removeAllByIndex(startSearchFromIndex, toRemove); // We don't need to care about if the startSearchFromIndex can be -1 here, since if it is -1, then the toRemove list is empty and the call will fast fail
++            var end = System.nanoTime();
++            System.out.println("(current tick: " + this.getServer().getTickCount() + ") startSearchFromIndex: " + startSearchFromIndex + " - toRemove: " + toRemove);
++            diffNew = end - start;
++            System.out.println("New version deleted " + toRemove.size() + " elements, took " + diffNew + "ns");
++        }
++        if (toRemove.size() != 0) {
++            System.out.println("Equals? " + oldList.equals(this.blockEntityTickers));
++            String winner = "Unknown";
++            long perfIncrease = 0;
++            if (diffOld > diffNew) {
++                winner = "New Version";
++                perfIncrease = diffOld - diffNew;
++            } else {
++                winner = "Old Version";
++                perfIncrease = diffNew - diffOld;
++            }
++            System.out.println("Who won? " + winner + ", by " + perfIncrease + "ns");
++        }
+         // SparklyPaper end
+         this.timings.tileEntityTick.stopTiming(); // Spigot
+         this.tickingBlockEntities = false;

patches/server/outdated/0022-Ignore-useless-entity-packets.patch

@@ -0,0 +1,54 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: AlphaKR93 <dev@alpha93.kr>
+Date: Wed, 27 Sep 2023 22:35:19 +0900
+Subject: [PATCH] Ignore useless entity packets
+
+[REFERENCE]
+- PurpurMC/Purpur
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
+index c3a4fcf600e72f9e95e9df673619ce37d0480cca..2b4d3db901784a82e1ed91520a5e3d1fb8ca6b3e 100644
+--- a/src/main/java/net/minecraft/server/level/ServerEntity.java
++++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
+@@ -214,6 +214,8 @@ public class ServerEntity {
+                         flag4 = true;
+                         flag5 = true;
+                     }
++
++                    if (this.level.plazmaConfig().entity.ignoreUselessPackets && isUselessPacket(packet1)) packet1 = null; // Plazma - Ignore useless entity packets
+                 }
+ 
+                 if ((this.trackDelta || this.entity.hasImpulse || this.entity instanceof LivingEntity && ((LivingEntity) this.entity).isFallFlying()) && this.tickCount > 0) {
+@@ -297,6 +299,19 @@ public class ServerEntity {
+         });
+     }
+ 
++    // Plazma start - Ignore useless entity packets
++    private boolean isUselessPacket(@Nullable Packet<?> packet) {
++        if (!(packet instanceof ClientboundMoveEntityPacket p)) return false;
++        if (p instanceof ClientboundMoveEntityPacket.Pos)
++            return p.getXa() == 0 && p.getYa() == 0 && p.getZa() == 0;
++        if (p instanceof ClientboundMoveEntityPacket.Rot)
++            return p.getxRot() == 0 && p.getyRot() == 0;
++        if (p instanceof ClientboundMoveEntityPacket.PosRot)
++            return p.getXa() == 0 && p.getYa() == 0 && p.getZa() == 0 && p.getxRot() == 0 && p.getyRot() == 0;
++        return false;
++    }
++    // Plazma end - Ignore useless entity packets
++
+     public void removePairing(ServerPlayer player) {
+         this.entity.stopSeenByPlayer(player);
+         player.connection.send(new ClientboundRemoveEntitiesPacket(new int[]{this.entity.getId()}));
+diff --git a/src/main/java/org/plazmamc/plazma/configurations/WorldConfigurations.java b/src/main/java/org/plazmamc/plazma/configurations/WorldConfigurations.java
+index b83a1058484e3d4d46f91d659f795f59d7087b72..9debf554deb5b7aa021502ff7d600905f56fa25c 100644
+--- a/src/main/java/org/plazmamc/plazma/configurations/WorldConfigurations.java
++++ b/src/main/java/org/plazmamc/plazma/configurations/WorldConfigurations.java
+@@ -29,6 +29,8 @@ public class WorldConfigurations extends ConfigurationPart {
+     public Entity entity;
+     public class Entity extends ConfigurationPart {
+ 
++        public boolean ignoreUselessPackets = OPTIMIZE;
++
+         public Phantom phantom;
+         public class Phantom extends ConfigurationPart {
+ 

patches/server/outdated/0032-Optimize-spigot-event-bus.patch

@@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: AlphaKR93 <dev@alpha93.kr>
+Date: Mon, 4 Dec 2023 23:19:46 +0900
+Subject: [PATCH] Optimize spigot event bus
+
+
+diff --git a/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java b/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java
+index 23594fb7eb4b2f33146592866608c2858ef23937..94eecf374f1e6b00556a380fd28376f720d61e8e 100644
+--- a/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java
++++ b/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java
+@@ -39,12 +39,19 @@ class PaperEventManager {
+         // Plazma start - Skip event if no listeners
+         RegisteredListener[] listeners = event.getHandlers().getRegisteredListeners();
+         if (listeners.length == 0) return;
+-        // Plazma end
+-        if (event.isAsynchronous() && this.server.isPrimaryThread()) {
+-            throw new IllegalStateException(event.getEventName() + " may only be triggered asynchronously.");
+-        } else if (!event.isAsynchronous() && !this.server.isPrimaryThread() && !this.server.isStopping()) {
+-            throw new IllegalStateException(event.getEventName() + " may only be triggered synchronously.");
++
++        // Optimize Spigot event bus
++        if (event.asynchronous() == net.kyori.adventure.util.TriState.NOT_SET) {
++            boolean async = event.isAsynchronous();
++            boolean primary = this.server.isPrimaryThread();
++
++            if (async && primary)
++                throw new IllegalStateException(event.getEventName() + " may only be triggered asynchronously.");
++
++            if (!async && !primary && !this.server.isStopping())
++                throw new IllegalStateException(event.getEventName() + " may only be triggered synchronously.");
+         }
++        // Plazma end
+ 
+         for (RegisteredListener registration : listeners) {
+             if (!registration.getPlugin().isEnabled()) {

patches/server/outdated/0037-Implement-FerriteCore.patch

@@ -0,0 +1,155 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: IPECTER <ipectert@gmail.com>
+Date: Wed, 10 May 2023 13:32:42 +0900
+Subject: [PATCH] Implement FerriteCore
+
+Original: malte0811/FerriteCore
+Copyright (C) 2023 malte0811
+
+diff --git a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+index 942ce713afe27ec75d849877a88721ef6334fafa..595771af13659fcb365fd3f088762dc01964842f 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
++++ b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+@@ -789,6 +789,12 @@ public abstract class BlockBehaviour implements FeatureElement {
+         protected BlockBehaviour.BlockStateBase.Cache cache;
+         private FluidState fluidState;
+         private boolean isRandomlyTicking;
++        // Plazma start - FerriteCore
++        public static final java.util.Map<net.minecraft.world.phys.shapes.VoxelShape, net.minecraft.world.phys.shapes.VoxelShape> CACHE_COLLIDE = new java.util.HashMap<>();
++        public static final java.util.Map<VoxelShape, org.apache.commons.lang3.tuple.Pair<VoxelShape, VoxelShape[]>> CACHE_PROJECT = new java.util.HashMap<>();
++        public static final java.util.Map<boolean[], boolean[]> CACHE_FACE_STURDY = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenCustomHashMap<>(it.unimi.dsi.fastutil.booleans.BooleanArrays.HASH_STRATEGY);
++        private static final ThreadLocal<BlockBehaviour.BlockStateBase.Cache> LAST_CACHE = new ThreadLocal<>();
++        // Plazma end
+ 
+         protected BlockStateBase(Block block, ImmutableMap<Property<?>, Comparable<?>> propertyMap, MapCodec<BlockState> codec) {
+             super(block, propertyMap, codec);
+@@ -871,6 +877,7 @@ public abstract class BlockBehaviour implements FeatureElement {
+         // Paper end
+ 
+         public void initCache() {
++            LAST_CACHE.set(asState().cache); // Plazma - FerriteCore
+             this.fluidState = ((Block) this.owner).getFluidState(this.asState());
+             this.isRandomlyTicking = ((Block) this.owner).isRandomlyTicking(this.asState());
+             if (!this.getBlock().hasDynamicShape()) {
+@@ -909,7 +916,61 @@ public abstract class BlockBehaviour implements FeatureElement {
+                 }
+             }
+             // Paper end
++            // Plazma start - FerriteCore
++            if (asState().cache != null) {
++                Cache newCache = asState().cache;
++                final Cache oldCache = LAST_CACHE.get();
++                VoxelShape dedupedCollisionShape;
++                if (oldCache != null && oldCache.collisionShape.equals(newCache.collisionShape)) {
++                    dedupedCollisionShape = oldCache.collisionShape;
++                } else {
++                    dedupedCollisionShape = CACHE_COLLIDE.computeIfAbsent(newCache.collisionShape, Function.identity());
++                }
++                if (dedupedCollisionShape instanceof net.minecraft.world.phys.shapes.ArrayVoxelShape keepArray && newCache.collisionShape instanceof net.minecraft.world.phys.shapes.ArrayVoxelShape replaceArray) {
++                    replaceInternals(keepArray, replaceArray);
++                }
++                newCache.collisionShape = dedupedCollisionShape;
++                final VoxelShape newRenderShape = getRenderShape(newCache.occlusionShapes);
++                if (newRenderShape == null)  return;
++                org.apache.commons.lang3.tuple.Pair<VoxelShape, VoxelShape[]> dedupedRenderShapes = null;
++                if (oldCache != null) {
++                    final VoxelShape oldRenderShape = getRenderShape(oldCache.occlusionShapes);
++                    if (newRenderShape.equals(oldRenderShape)) dedupedRenderShapes = org.apache.commons.lang3.tuple.Pair.of(oldRenderShape, oldCache.occlusionShapes);
++                }
++                if (dedupedRenderShapes == null) {
++                    org.apache.commons.lang3.tuple.Pair<VoxelShape, VoxelShape[]> newPair = org.apache.commons.lang3.tuple.Pair.of(newRenderShape, newCache.occlusionShapes);
++                    dedupedRenderShapes = CACHE_PROJECT.putIfAbsent(newRenderShape, newPair);
++                    if (dedupedRenderShapes == null) dedupedRenderShapes = newPair;
++                }
++                if (dedupedRenderShapes.getLeft() instanceof net.minecraft.world.phys.shapes.ArrayVoxelShape keepArray && newRenderShape instanceof net.minecraft.world.phys.shapes.ArrayVoxelShape replaceArray) {
++                    replaceInternals(keepArray, replaceArray);
++                }
++                newCache.occlusionShapes = dedupedRenderShapes.getRight();
++                boolean equalCheck = oldCache != null && Arrays.equals(oldCache.faceSturdy, newCache.faceSturdy);
++                newCache.faceSturdy = equalCheck ? oldCache.faceSturdy : CACHE_FACE_STURDY.computeIfAbsent(newCache.faceSturdy, Function.identity());
++                LAST_CACHE.set(null);
++            }
++            // Plazma end
++        }
++
++        // Plazma start - FerriteCore
++        private void replaceInternals(net.minecraft.world.phys.shapes.ArrayVoxelShape toKeep, net.minecraft.world.phys.shapes.ArrayVoxelShape toReplace) {
++            if (toKeep == toReplace) return;
++            toReplace.xs = toKeep.xs;
++            toReplace.ys = toKeep.ys;
++            toReplace.zs = toKeep.zs;
++            toReplace.faces = toKeep.faces;
++            toReplace.shape = toKeep.shape;
++        }
++
++        @Nullable
++        private static VoxelShape getRenderShape(@Nullable VoxelShape[] projected) {
++            if (projected != null) {
++                for (VoxelShape side : projected) if (side instanceof net.minecraft.world.phys.shapes.SliceShape slice) return slice.getDelegate();
++            }
++            return null;
+         }
++        // Plazma end
+ 
+         public Block getBlock() {
+             return (Block) this.owner;
+@@ -1305,10 +1366,10 @@ public abstract class BlockBehaviour implements FeatureElement {
+             final boolean propagatesSkylightDown;
+             final int lightBlock;
+             @Nullable
+-            final VoxelShape[] occlusionShapes;
+-            protected final VoxelShape collisionShape;
++            public VoxelShape[] occlusionShapes; // Plazma - FerriteCore - final -> public
++            public VoxelShape collisionShape; // Plazma - FerriteCore - protected final -> public
+             protected final boolean largeCollisionShape;
+-            private final boolean[] faceSturdy;
++            public boolean[] faceSturdy; // Plazma - FerriteCore - private final -> public
+             protected final boolean isCollisionShapeFullBlock;
+ 
+             Cache(BlockState state) {
+diff --git a/src/main/java/net/minecraft/world/phys/shapes/ArrayVoxelShape.java b/src/main/java/net/minecraft/world/phys/shapes/ArrayVoxelShape.java
+index ca5f01be5d5ccfcc56780ff93cca3824409ffc0d..767311b27219d830ef049df94314f0871ac9afff 100644
+--- a/src/main/java/net/minecraft/world/phys/shapes/ArrayVoxelShape.java
++++ b/src/main/java/net/minecraft/world/phys/shapes/ArrayVoxelShape.java
+@@ -10,9 +10,9 @@ import net.minecraft.core.Direction;
+ import it.unimi.dsi.fastutil.doubles.AbstractDoubleList;
+ // Paper end
+ public class ArrayVoxelShape extends VoxelShape {
+-    private final DoubleList xs;
+-    private final DoubleList ys;
+-    private final DoubleList zs;
++    public DoubleList xs; // Plazma - FerriteCore - private final -> public
++    public DoubleList ys; // Plazma - FerriteCore - private final -> public
++    public DoubleList zs; // Plazma - FerriteCore - private final -> public
+ 
+     protected ArrayVoxelShape(DiscreteVoxelShape shape, double[] xPoints, double[] yPoints, double[] zPoints) {
+         this(shape, (DoubleList)DoubleArrayList.wrap(Arrays.copyOf(xPoints, shape.getXSize() + 1)), (DoubleList)DoubleArrayList.wrap(Arrays.copyOf(yPoints, shape.getYSize() + 1)), (DoubleList)DoubleArrayList.wrap(Arrays.copyOf(zPoints, shape.getZSize() + 1)));
+diff --git a/src/main/java/net/minecraft/world/phys/shapes/SliceShape.java b/src/main/java/net/minecraft/world/phys/shapes/SliceShape.java
+index cf469f9daa81da8bc330c9cac7e813db87f9f9af..bcd094d6746d8102b04ce6547db6d4bc497463e8 100644
+--- a/src/main/java/net/minecraft/world/phys/shapes/SliceShape.java
++++ b/src/main/java/net/minecraft/world/phys/shapes/SliceShape.java
+@@ -4,7 +4,7 @@ import it.unimi.dsi.fastutil.doubles.DoubleList;
+ import net.minecraft.core.Direction;
+ 
+ public class SliceShape extends VoxelShape {
+-    private final VoxelShape delegate;
++    private final VoxelShape delegate; public VoxelShape getDelegate() { return this.delegate; } // Plazma - FerriteCore
+     private final Direction.Axis axis;
+     private static final DoubleList SLICE_COORDS = new CubePointRange(1);
+ 
+diff --git a/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java b/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java
+index 2182afd1b95acf14c55bddfeec17dae0a63e1f00..5fc28a6a09b251ce7adbb93e30045869ea43718a 100644
+--- a/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java
++++ b/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java
+@@ -16,9 +16,9 @@ import net.minecraft.world.phys.BlockHitResult;
+ import net.minecraft.world.phys.Vec3;
+ 
+ public abstract class VoxelShape {
+-    public final DiscreteVoxelShape shape; // Paper - public
++    public DiscreteVoxelShape shape; // Paper - public // Plazma - FerriteCore - public final -> public
+     @Nullable
+-    private VoxelShape[] faces;
++    public VoxelShape[] faces; // Plazma - FerriteCore - private -> public
+ 
+     // Paper start
+     public boolean intersects(AABB shape) {

patches/server/outdated/purpur/0013-LivingEntity-safeFallDistance.patch

@@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Sun, 5 May 2019 12:58:45 -0500
+Subject: [PATCH] LivingEntity safeFallDistance
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index aa351df679f300018367244c7ccb3e5a59e9276f..39c2a9f732b8e2452fd2dca07193a173d0c2ba1c 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -1173,4 +1173,16 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+         this.getHandle().setYBodyRot(bodyYaw);
+     }
+     // Paper end - body yaw API
++
++    // Purpur start
++    @Override
++    public float getSafeFallDistance() {
++        return (float) getHandle().getAttributeValue(Attributes.SAFE_FALL_DISTANCE);
++    }
++
++    @Override
++    public void setSafeFallDistance(float safeFallDistance) {
++        getHandle().getAttribute(Attributes.SAFE_FALL_DISTANCE).setBaseValue(safeFallDistance);
++    }
++    // Purpur end
+ }

patches/server/outdated/purpur/0040-End-gateway-should-check-if-entity-can-use-portal.patch

@@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 21 Mar 2020 18:33:05 -0500
+Subject: [PATCH] End gateway should check if entity can use portal
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
+index 93bd70c1dc2ba8b893a6087730071c81fb1132f4..60b343edc4383c8bc450f106f483349850432fa3 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
+@@ -167,6 +167,7 @@ public class TheEndGatewayBlockEntity extends TheEndPortalBlockEntity {
+ 
+     public static void teleportEntity(Level world, BlockPos pos, BlockState state, Entity entity, TheEndGatewayBlockEntity blockEntity) {
+         if (world instanceof ServerLevel worldserver && !blockEntity.isCoolingDown()) {
++            if (!entity.canChangeDimensions()) return; // Purpur
+             blockEntity.teleportCooldown = 100;
+             BlockPos blockposition1;
+ 

patches/server/outdated/purpur/0082-LivingEntity-broadcastItemBreak.patch

@@ -0,0 +1,23 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Mon, 17 Aug 2020 21:50:39 -0500
+Subject: [PATCH] LivingEntity#broadcastItemBreak
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index a1e715629313346f670bce92483996122b0f1d7b..386647f6000c71c59ab8d7875219eefdc5a3d7ef 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -1181,4 +1181,12 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+         this.getHandle().setYBodyRot(bodyYaw);
+     }
+     // Paper end - body yaw API
++
++    // Purpur start
++    @Override
++    public void broadcastItemBreak(org.bukkit.inventory.EquipmentSlot slot) {
++        if (slot == null) return;
++        getHandle().broadcastBreakEvent(org.bukkit.craftbukkit.CraftEquipmentSlot.getNMS(slot));
++    }
++    // Purpur end
+ }

patches/server/outdated/purpur/0094-Allow-infinite-and-mending-enchantments-together.patch

@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Tue, 13 Oct 2020 20:04:33 -0500
+Subject: [PATCH] Allow infinite and mending enchantments together
+
+
+diff --git a/src/main/java/net/minecraft/world/item/enchantment/ArrowInfiniteEnchantment.java b/src/main/java/net/minecraft/world/item/enchantment/ArrowInfiniteEnchantment.java
+index 81cc05c929d612898609965d82454b89cd18f9f5..fa73c3d4b58ad8379963a9866d8f09e1d6abd663 100644
+--- a/src/main/java/net/minecraft/world/item/enchantment/ArrowInfiniteEnchantment.java
++++ b/src/main/java/net/minecraft/world/item/enchantment/ArrowInfiniteEnchantment.java
+@@ -7,6 +7,6 @@ public class ArrowInfiniteEnchantment extends Enchantment {
+ 
+     @Override
+     public boolean checkCompatibility(Enchantment other) {
+-        return !(other instanceof MendingEnchantment) && super.checkCompatibility(other);
++        return !(other instanceof MendingEnchantment) && super.checkCompatibility(other) || other instanceof MendingEnchantment && org.purpurmc.purpur.PurpurConfig.allowInfinityMending; // Purpur
+     }
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 2f68cf2fc064a38ca059504a39d563d95d01643e..6d621a93aaf94927fa6c73e649dcdb8bbbaadd2a 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -246,6 +246,16 @@ public class PurpurConfig {
+         cryingObsidianValidForPortalFrame = getBoolean("settings.blocks.crying_obsidian.valid-for-portal-frame", cryingObsidianValidForPortalFrame);
+     }
+ 
++    public static boolean allowInfinityMending = false;
++    private static void enchantmentSettings() {
++        if (version < 5) {
++            boolean oldValue = getBoolean("settings.enchantment.allow-infinite-and-mending-together", false);
++            set("settings.enchantment.allow-infinity-and-mending-together", oldValue);
++            set("settings.enchantment.allow-infinite-and-mending-together", null);
++        }
++        allowInfinityMending = getBoolean("settings.enchantment.allow-infinity-and-mending-together", allowInfinityMending);
++    }
++
+     public static boolean endermanShortHeight = false;
+     private static void entitySettings() {
+         endermanShortHeight = getBoolean("settings.entity.enderman.short-height", endermanShortHeight);

patches/server/outdated/purpur/0142-Allow-infinity-on-crossbows.patch

@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Ben Kerllenevich <ben@omega24.dev>
+Date: Thu, 18 Mar 2021 12:25:29 -0400
+Subject: [PATCH] Allow infinity on crossbows
+
+
+diff --git a/src/main/java/net/minecraft/world/item/CrossbowItem.java b/src/main/java/net/minecraft/world/item/CrossbowItem.java
+index 1f52feb5684ee1bab710e1557cf69b43b4d4dfd4..d2bb5c84e1895f28afed03d1868a79338e4f3e58 100644
+--- a/src/main/java/net/minecraft/world/item/CrossbowItem.java
++++ b/src/main/java/net/minecraft/world/item/CrossbowItem.java
+@@ -107,7 +107,7 @@ public class CrossbowItem extends ProjectileWeaponItem {
+         return CrossbowItem.tryLoadProjectiles(shooter, crossbow, true);
+     }
+     private static boolean tryLoadProjectiles(LivingEntity shooter, ItemStack crossbow, boolean consume) {
+-        List<ItemStack> list = draw(crossbow, shooter.getProjectile(crossbow), shooter, consume);
++        List<ItemStack> list = draw(crossbow, shooter.getProjectile(crossbow), shooter, (org.purpurmc.purpur.PurpurConfig.allowCrossbowInfinity && EnchantmentHelper.getItemEnchantmentLevel(Enchantments.INFINITY, crossbow) > 0) || consume);
+         // Paper end - Add EntityLoadCrossbowEvent
+         if (!list.isEmpty()) {
+             crossbow.set(DataComponents.CHARGED_PROJECTILES, ChargedProjectiles.of(list));
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 0587b0c7f34ae90f0d06f29d58fafbcf5b80ff13..c60d0d1861fd24b74bfa93228357f27d524f4ce7 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -284,6 +284,7 @@ public class PurpurConfig {
+     }
+ 
+     public static boolean allowInfinityMending = false;
++    public static boolean allowCrossbowInfinity = true;
+     private static void enchantmentSettings() {
+         if (version < 5) {
+             boolean oldValue = getBoolean("settings.enchantment.allow-infinite-and-mending-together", false);
+@@ -291,6 +292,7 @@ public class PurpurConfig {
+             set("settings.enchantment.allow-infinite-and-mending-together", null);
+         }
+         allowInfinityMending = getBoolean("settings.enchantment.allow-infinity-and-mending-together", allowInfinityMending);
++        allowCrossbowInfinity = getBoolean("settings.enchantment.allow-infinity-on-crossbow", allowCrossbowInfinity);
+     }
+ 
+     public static boolean endermanShortHeight = false;

patches/server/outdated/purpur/0220-Potion-NamespacedKey.patch

@@ -0,0 +1,223 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Racci <tangentmoons@gmail.com>
+Date: Sat, 4 Dec 2021 00:07:05 +1100
+Subject: [PATCH] Potion NamespacedKey
+
+
+diff --git a/src/main/java/net/minecraft/world/effect/MobEffectInstance.java b/src/main/java/net/minecraft/world/effect/MobEffectInstance.java
+index 32cf6ea96aaa2e6bd0cc28fa88492ceea3d34052..9787dd4fc6ca2ed8aba3db7674ad2dc26a529a7a 100644
+--- a/src/main/java/net/minecraft/world/effect/MobEffectInstance.java
++++ b/src/main/java/net/minecraft/world/effect/MobEffectInstance.java
+@@ -53,6 +53,7 @@ public class MobEffectInstance implements Comparable<MobEffectInstance> {
+     private boolean showIcon;
+     @Nullable
+     public MobEffectInstance hiddenEffect;
++    private org.bukkit.NamespacedKey key; // Purpur - add key
+     private final MobEffectInstance.BlendState blendState = new MobEffectInstance.BlendState();
+ 
+     public MobEffectInstance(Holder<MobEffect> effect) {
+@@ -71,8 +72,14 @@ public class MobEffectInstance implements Comparable<MobEffectInstance> {
+         this(effect, duration, amplifier, ambient, visible, visible);
+     }
+ 
++    // Purpur start
++    public MobEffectInstance(Holder<MobEffect> effect, int duration, int amplifier, boolean ambient, boolean showParticles, boolean showIcon, @Nullable org.bukkit.NamespacedKey key) {
++        this(effect, duration, amplifier, ambient, showParticles, showIcon, null, key);
++    // Purpur end
++    }
++
+     public MobEffectInstance(Holder<MobEffect> effect, int duration, int amplifier, boolean ambient, boolean showParticles, boolean showIcon) {
+-        this(effect, duration, amplifier, ambient, showParticles, showIcon, null);
++        this(effect, duration, amplifier, ambient, showParticles, showIcon, null, null); // Purpur
+     }
+ 
+     public MobEffectInstance(
+@@ -82,7 +89,8 @@ public class MobEffectInstance implements Comparable<MobEffectInstance> {
+         boolean ambient,
+         boolean showParticles,
+         boolean showIcon,
+-        @Nullable MobEffectInstance hiddenEffect
++        @Nullable MobEffectInstance hiddenEffect,
++        @Nullable org.bukkit.NamespacedKey key // Purpur
+     ) {
+         this.effect = effect;
+         this.duration = duration;
+@@ -90,6 +98,7 @@ public class MobEffectInstance implements Comparable<MobEffectInstance> {
+         this.ambient = ambient;
+         this.visible = showParticles;
+         this.showIcon = showIcon;
++        this.key = key; // Purpur - add key
+         this.hiddenEffect = hiddenEffect;
+     }
+ 
+@@ -135,6 +144,7 @@ public class MobEffectInstance implements Comparable<MobEffectInstance> {
+         this.ambient = that.ambient;
+         this.visible = that.visible;
+         this.showIcon = that.showIcon;
++        this.key = that.key; // Purpur - add key
+     }
+ 
+     public boolean update(MobEffectInstance that) {
+@@ -179,6 +189,13 @@ public class MobEffectInstance implements Comparable<MobEffectInstance> {
+             bl = true;
+         }
+ 
++        // Purpur start
++        if (that.key != this.key) {
++            this.key = that.key;
++            bl = true;
++        }
++        // Purpur end
++
+         return bl;
+     }
+ 
+@@ -222,6 +239,17 @@ public class MobEffectInstance implements Comparable<MobEffectInstance> {
+         return this.showIcon;
+     }
+ 
++    // Purpur start
++    public boolean hasKey() {
++        return this.key != null;
++    }
++
++    @Nullable
++    public org.bukkit.NamespacedKey getKey() {
++        return this.key;
++    }
++    // Purpur end
++
+     public boolean tick(LivingEntity entity, Runnable overwriteCallback) {
+         if (this.hasRemainingDuration()) {
+             int i = this.isInfiniteDuration() ? entity.tickCount : this.duration;
+@@ -286,6 +314,12 @@ public class MobEffectInstance implements Comparable<MobEffectInstance> {
+             string = string + ", Show Icon: false";
+         }
+ 
++        // Purpur start
++        if (this.hasKey()) {
++            string = string + ", Key: " + this.key;
++        }
++        // Purpur end
++
+         return string;
+     }
+ 
+@@ -300,6 +334,7 @@ public class MobEffectInstance implements Comparable<MobEffectInstance> {
+                 && this.duration == mobEffectInstance.duration
+                 && this.amplifier == mobEffectInstance.amplifier
+                 && this.ambient == mobEffectInstance.ambient
++                && this.key == mobEffectInstance.key // Purpur - add key
+                 && this.effect.equals(mobEffectInstance.effect);
+     }
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaPotion.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaPotion.java
+index 4a9e6a679530025caa710a152c5249299ceffdf9..ea4f3f606aad69965384c73eb1273ed0644297b8 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaPotion.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaPotion.java
+@@ -42,6 +42,7 @@ class CraftMetaPotion extends CraftMetaItem implements PotionMeta {
+     static final ItemMetaKey POTION_EFFECTS = new ItemMetaKey("custom-effects");
+     static final ItemMetaKey POTION_COLOR = new ItemMetaKey("custom-color");
+     static final ItemMetaKey DEFAULT_POTION = new ItemMetaKey("potion-type");
++    static final ItemMetaKey KEY = new ItemMetaKey("key", "namespacedkey"); // Purpur - add key
+ 
+     private PotionType type;
+     private List<PotionEffect> customEffects;
+@@ -91,7 +92,13 @@ class CraftMetaPotion extends CraftMetaItem implements PotionMeta {
+                 boolean ambient = effect.isAmbient();
+                 boolean particles = effect.isVisible();
+                 boolean icon = effect.showIcon();
+-                this.customEffects.add(new PotionEffect(type, duration, amp, ambient, particles, icon));
++                // Purpur start
++                NamespacedKey key = null;
++                if (tag.contains(CraftMetaPotion.KEY.NBT)) {
++                    key = NamespacedKey.fromString(effect.getString(CraftMetaPotion.KEY.NBT));
++                }
++                this.customEffects.add(new PotionEffect(type, duration, amp, ambient, particles, icon, key));
++                // Purpur end
+             }
+         });
+     }
+@@ -130,6 +137,11 @@ class CraftMetaPotion extends CraftMetaItem implements PotionMeta {
+         if (this.customEffects != null) {
+             for (PotionEffect effect : this.customEffects) {
+                 effectList.add(new MobEffectInstance(CraftPotionEffectType.bukkitToMinecraftHolder(effect.getType()), effect.getDuration(), effect.getAmplifier(), effect.isAmbient(), effect.hasParticles(), effect.hasIcon()));
++                // Purpur start
++                if (effect.hasKey()) {
++                    effectData.putString(CraftMetaPotion.KEY.NBT, effect.getKey().toString());
++                }
++                // Purpur end
+             }
+         }
+ 
+@@ -196,7 +208,7 @@ class CraftMetaPotion extends CraftMetaItem implements PotionMeta {
+         if (index != -1) {
+             if (overwrite) {
+                 PotionEffect old = this.customEffects.get(index);
+-                if (old.getAmplifier() == effect.getAmplifier() && old.getDuration() == effect.getDuration() && old.isAmbient() == effect.isAmbient()) {
++                if (old.getAmplifier() == effect.getAmplifier() && old.getDuration() == effect.getDuration() && old.isAmbient() == effect.isAmbient() && old.getKey() == effect.getKey()) { // Purpur - add key
+                     return false;
+                 }
+                 this.customEffects.set(index, effect);
+diff --git a/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionUtil.java b/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionUtil.java
+index 14c58cf8d255c51473fd3d0092faeaf5a3c1ae0c..3ee9c14440046872b83de628b7f460d0782e9315 100644
+--- a/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionUtil.java
++++ b/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionUtil.java
+@@ -11,7 +11,7 @@ public class CraftPotionUtil {
+     public static MobEffectInstance fromBukkit(PotionEffect effect) {
+         Holder<MobEffect> type = CraftPotionEffectType.bukkitToMinecraftHolder(effect.getType());
+         // Paper - Note: do not copy over the hidden effect, as this method is only used for applying to entities which we do not want to convert over.
+-        return new MobEffectInstance(type, effect.getDuration(), effect.getAmplifier(), effect.isAmbient(), effect.hasParticles(), effect.hasIcon()); // Paper
++        return new MobEffectInstance(type, effect.getDuration(), effect.getAmplifier(), effect.isAmbient(), effect.hasParticles(), effect.hasIcon(), effect.getKey()); // Paper // Purpur - add key
+     }
+ 
+     public static PotionEffect toBukkit(MobEffectInstance effect) {
+@@ -20,7 +20,7 @@ public class CraftPotionUtil {
+         int duration = effect.getDuration();
+         boolean ambient = effect.isAmbient();
+         boolean particles = effect.isVisible();
+-        return new PotionEffect(type, duration, amp, ambient, particles, effect.showIcon(), effect.hiddenEffect == null ? null : toBukkit(effect.hiddenEffect)); // Paper
++        return new PotionEffect(type, duration, amp, ambient, particles, effect.showIcon(), effect.hiddenEffect == null ? null : toBukkit(effect.hiddenEffect), effect.getKey()); // Paper // Purpur - add key
+     }
+ 
+     public static boolean equals(Holder<MobEffect> mobEffect, PotionEffectType type) {
+diff --git a/src/test/java/org/bukkit/potion/PotionTest.java b/src/test/java/org/bukkit/potion/PotionTest.java
+index cbcd1c21646308b2a9706095e2e12177ca06734d..b3ccaea713e858e334cc91d1ae498e589e3daafa 100644
+--- a/src/test/java/org/bukkit/potion/PotionTest.java
++++ b/src/test/java/org/bukkit/potion/PotionTest.java
+@@ -10,6 +10,7 @@ import net.minecraft.world.effect.MobEffect;
+ import net.minecraft.world.effect.MobEffectInstance;
+ import net.minecraft.world.item.alchemy.Potion;
+ import org.bukkit.craftbukkit.legacy.FieldRename;
++import org.bukkit.NamespacedKey; // Purpur
+ import org.bukkit.craftbukkit.potion.CraftPotionEffectType;
+ import org.bukkit.support.AbstractTestingBase;
+ import org.junit.jupiter.api.Test;
+@@ -47,4 +48,27 @@ public class PotionTest extends AbstractTestingBase {
+             assertEquals(bukkit, byName, "Same type not returned by name " + key);
+         }
+     }
++
++    // Purpur start
++    @Test
++    public void testNamespacedKey() {
++        NamespacedKey key = new NamespacedKey("testnamespace", "testkey");
++        PotionEffect namedSpacedEffect = new PotionEffect(PotionEffectType.DOLPHINS_GRACE, 20, 0, true, true, true, key);
++        assertNotNull(namedSpacedEffect.getKey());
++        assertTrue(namedSpacedEffect.hasKey());
++        assertFalse(namedSpacedEffect.withKey(null).hasKey());
++
++        PotionEffect effect = new PotionEffect(PotionEffectType.DOLPHINS_GRACE, 20, 0, true, true, true);
++        assertNull(effect.getKey());
++        assertFalse(effect.hasKey());
++        assertTrue(namedSpacedEffect.withKey(key).hasKey());
++
++        Map<String, Object> s1 = namedSpacedEffect.serialize();
++        Map<String, Object> s2 = effect.serialize();
++        assertTrue(s1.containsKey("namespacedKey"));
++        assertFalse(s2.containsKey("namespacedKey"));
++        assertNotNull(new PotionEffect(s1).getKey());
++        assertNull(new PotionEffect(s2).getKey());
++    }
++    // Purpur end
+ }

patches/server/outdated/purpur/0236-Configurable-food-attributes.patch

@@ -0,0 +1,149 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@Gmail.com>
+Date: Tue, 18 Jan 2022 04:51:51 -0600
+Subject: [PATCH] Configurable food attributes
+
+
+diff --git a/src/main/java/net/minecraft/world/food/FoodProperties.java b/src/main/java/net/minecraft/world/food/FoodProperties.java
+index 9967ba762567631f2bdb1e4f8fe16a13ea927b46..6c945ae8fe8b1517e312c688f829fab41f12d9f4 100644
+--- a/src/main/java/net/minecraft/world/food/FoodProperties.java
++++ b/src/main/java/net/minecraft/world/food/FoodProperties.java
+@@ -2,15 +2,22 @@ package net.minecraft.world.food;
+ 
+ import com.google.common.collect.Lists;
+ import com.mojang.datafixers.util.Pair;
++
++import java.util.ArrayList;
+ import java.util.List;
+ import net.minecraft.world.effect.MobEffectInstance;
+ 
+ public class FoodProperties {
+-    private final int nutrition;
+-    private final float saturationModifier;
+-    private final boolean isMeat;
+-    private final boolean canAlwaysEat;
+-    private final boolean fastFood;
++    // Purpur start
++    private int nutrition; public void setNutrition(int nutrition) { this.nutrition = nutrition; }
++    private float saturationModifier; public void setSaturationModifier(float saturation) { this.saturationModifier = saturation; }
++    private boolean isMeat; public void setIsMeat(boolean isMeat) { this.isMeat = isMeat; }
++    private boolean canAlwaysEat; public void setCanAlwaysEat(boolean canAlwaysEat) { this.canAlwaysEat = canAlwaysEat; }
++    private boolean fastFood; public void setFastFood(boolean isFastFood) { this.fastFood = isFastFood; }
++    public FoodProperties copy() {
++        return new FoodProperties(this.nutrition, this.saturationModifier, this.isMeat, this.canAlwaysEat, this.fastFood, new ArrayList<>(this.effects));
++    }
++    // Purpur end
+     private final List<Pair<MobEffectInstance, Float>> effects;
+ 
+     FoodProperties(int hunger, float saturationModifier, boolean meat, boolean alwaysEdible, boolean snack, List<Pair<MobEffectInstance, Float>> statusEffects) {
+diff --git a/src/main/java/net/minecraft/world/food/Foods.java b/src/main/java/net/minecraft/world/food/Foods.java
+index 4569cf30b33167a415256a8542820557ad38f89e..9c65eefa855f3622b6c9ae2a698cf332ba225c7f 100644
+--- a/src/main/java/net/minecraft/world/food/Foods.java
++++ b/src/main/java/net/minecraft/world/food/Foods.java
+@@ -4,6 +4,8 @@ import net.minecraft.world.effect.MobEffectInstance;
+ import net.minecraft.world.effect.MobEffects;
+ 
+ public class Foods {
++    public static final java.util.Map<String, FoodProperties> ALL_PROPERTIES = new java.util.HashMap<>(); // Purpur
++    public static final java.util.Map<String, FoodProperties> DEFAULT_PROPERTIES = new java.util.HashMap<>(); // Purpur
+     public static final FoodProperties APPLE = new FoodProperties.Builder().nutrition(4).saturationMod(0.3F).build();
+     public static final FoodProperties BAKED_POTATO = new FoodProperties.Builder().nutrition(5).saturationMod(0.6F).build();
+     public static final FoodProperties BEEF = new FoodProperties.Builder().nutrition(3).saturationMod(0.3F).meat().build();
+diff --git a/src/main/java/net/minecraft/world/item/Items.java b/src/main/java/net/minecraft/world/item/Items.java
+index bb2103a488964f25335393fa91e8ae5749eca333..249c887af68f56739c3609bad2405ba2cbe11762 100644
+--- a/src/main/java/net/minecraft/world/item/Items.java
++++ b/src/main/java/net/minecraft/world/item/Items.java
+@@ -1715,6 +1715,13 @@ public class Items {
+             ((BlockItem)item).registerBlocks(Item.BY_BLOCK, item);
+         }
+ 
++        // Purpur start
++        if (item.getFoodProperties() != null) {
++            Foods.ALL_PROPERTIES.put(key.location().getPath(), item.getFoodProperties());
++            Foods.DEFAULT_PROPERTIES.put(key.location().getPath(), item.getFoodProperties().copy());
++        }
++        // Purpur end
++
+         return Registry.register(BuiltInRegistries.ITEM, key, item);
+     }
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 0e28cf20a870f3f3662bd1d8f7a4f2cbf13c48bf..ce3ab604e6ed6669f38abf83d40b500148277b9d 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -466,4 +466,75 @@ public class PurpurConfig {
+         String setPattern = getString("settings.username-valid-characters", defaultPattern);
+         usernameValidCharactersPattern = java.util.regex.Pattern.compile(setPattern == null || setPattern.isBlank() ? defaultPattern : setPattern);
+     }
++
++    private static void foodSettings() {
++        ConfigurationSection properties = config.getConfigurationSection("settings.food-properties");
++        if (properties == null) {
++            config.addDefault("settings.food-properties", new HashMap<>());
++            return;
++        }
++
++        Map<MobEffect, Map<String, Object>> effectDefaults = new HashMap<>();
++        Map<String, Object> EFFECT_DEFAULT = Map.of(
++            "chance", 0.0F,
++            "duration", 0,
++            "amplifier", 0,
++            "ambient", false,
++            "visible", true,
++            "show-icon", true
++        );
++
++        properties.getKeys(false).forEach(foodKey -> {
++            FoodProperties food = Foods.ALL_PROPERTIES.get(foodKey);
++            if (food == null) {
++                PurpurConfig.log(Level.SEVERE, "Invalid food property: " + foodKey);
++                return;
++            }
++            FoodProperties foodDefaults = Foods.DEFAULT_PROPERTIES.get(foodKey);
++            food.setNutrition(properties.getInt(foodKey + ".nutrition", foodDefaults.getNutrition()));
++            food.setSaturationModifier((float) properties.getDouble(foodKey + ".saturation-modifier", foodDefaults.getSaturationModifier()));
++            food.setIsMeat(properties.getBoolean(foodKey + ".is-meat", foodDefaults.isMeat()));
++            food.setCanAlwaysEat(properties.getBoolean(foodKey + ".can-always-eat", foodDefaults.canAlwaysEat()));
++            food.setFastFood(properties.getBoolean(foodKey + ".fast-food", foodDefaults.isFastFood()));
++            ConfigurationSection effects = properties.getConfigurationSection(foodKey + ".effects");
++            if (effects != null) {
++                effectDefaults.clear();
++                foodDefaults.getEffects().forEach(pair -> {
++                    MobEffectInstance effect = pair.getFirst();
++                    effectDefaults.put(effect.getEffect(), Map.of(
++                            "chance", pair.getSecond(),
++                            "duration", effect.getDuration(),
++                            "amplifier", effect.getAmplifier(),
++                            "ambient", effect.isAmbient(),
++                            "visible", effect.isVisible(),
++                            "show-icon", effect.showIcon()
++                    ));
++                });
++                effects.getKeys(false).forEach(effectKey -> {
++                    MobEffect effect = BuiltInRegistries.MOB_EFFECT.get(new ResourceLocation(effectKey));
++                    if (effect == null) {
++                        PurpurConfig.log(Level.SEVERE, "Invalid food property effect for " + foodKey + ": " + effectKey);
++                        return;
++                    }
++
++                    Map<String, Object> effectDefault = effectDefaults.get(effect);
++                    if (effectDefault == null) {
++                        effectDefault = EFFECT_DEFAULT;
++                    }
++
++                    food.getEffects().removeIf(pair -> pair.getFirst().getEffect() == effect);
++                    float chance = (float) effects.getDouble(effectKey + ".chance", ((Float) effectDefault.get("chance")).doubleValue());
++                    int duration = effects.getInt(effectKey + ".duration", (int) effectDefault.get("duration"));
++                    if (chance <= 0.0F || duration < 0) {
++                        return;
++                    }
++                    int amplifier = effects.getInt(effectKey + ".amplifier", (int) effectDefault.get("amplifier"));
++                    boolean ambient = effects.getBoolean(effectKey + ".ambient", (boolean) effectDefault.get("ambient"));
++                    boolean visible = effects.getBoolean(effectKey + ".visible", (boolean) effectDefault.get("visible"));
++                    boolean showIcon = effects.getBoolean(effectKey + ".show-icon", (boolean) effectDefault.get("show-icon"));
++                    food.getEffects().add(Pair.of(new MobEffectInstance(effect, duration, amplifier, ambient, visible, showIcon), chance));
++                });
++            }
++        });
++    }
+ }

patches/server/outdated/purpur/0255-Send-client-custom-name-of-BE.patch

@@ -0,0 +1,36 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Ben Kerllenevich <ben@omega24.dev>
+Date: Wed, 13 Jul 2022 16:27:43 -0400
+Subject: [PATCH] Send client custom name of BE
+
+https://modrinth.com/mod/know-my-name
+
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
+index 4ea15e17a1393864422edb6d5c57962651abf69a..a78ed43288cfefaeb2592ed0a33fd11565dea2b2 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
+@@ -256,10 +256,24 @@ public abstract class BlockEntity {
+ 
+     @Nullable
+     public Packet<ClientGamePacketListener> getUpdatePacket() {
++        // Purpur start
++        if (this instanceof net.minecraft.world.Nameable nameable && nameable.hasCustomName()) {
++            CompoundTag nbt = this.saveWithoutMetadata();
++            nbt.remove("Items");
++            return net.minecraft.network.protocol.game.ClientboundBlockEntityDataPacket.create(this, $ -> nbt);
++        }
++        // Purpur end
+         return null;
+     }
+ 
+     public CompoundTag getUpdateTag(HolderLookup.Provider registryLookup) {
++        // Purpur start
++        if (this instanceof net.minecraft.world.Nameable nameable && nameable.hasCustomName()) {
++            CompoundTag nbt = this.saveWithoutMetadata();
++            nbt.remove("Items");
++            return nbt;
++        }
++        // Purpur end
+         return new CompoundTag();
+     }
+ 

patches/server/outdated/purpur/0263-Allay-respect-item-NBT.patch

@@ -0,0 +1,64 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <blake.galbreath@gmail.com>
+Date: Tue, 20 Sep 2022 17:56:21 -0500
+Subject: [PATCH] Allay respect item NBT
+
+https://github.com/PurpurMC/Purpur/discussions/1127
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java
+index bca7b7192debb3a34a08047010a2438e7b7e2a78..53765198483e137d411e227119e4f912964aefe3 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java
++++ b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java
+@@ -399,9 +399,31 @@ public class Allay extends PathfinderMob implements InventoryCarrier, VibrationS
+ 
+     @Override
+     public boolean wantsToPickUp(ItemStack stack) {
+-        ItemStack itemstack1 = this.getItemInHand(InteractionHand.MAIN_HAND);
+-
+-        return !itemstack1.isEmpty() && this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING) && this.inventory.canAddItem(stack) && this.allayConsidersItemEqual(itemstack1, stack);
++        // Purpur start
++        if (!this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
++            return false;
++        }
++        ItemStack itemStack = this.getItemInHand(InteractionHand.MAIN_HAND);
++        if (itemStack.isEmpty()) {
++            return false;
++        }
++        if (!allayConsidersItemEqual(itemStack, stack)) {
++            return false;
++        }
++        if (!this.inventory.canAddItem(stack)) {
++            return false;
++        }
++        for (String tag : this.level().purpurConfig.allayRespectNBT) {
++            if (stack.hasTag() && itemStack.hasTag()) {
++                Tag tag1 = stack.getTag().get(tag);
++                Tag tag2 = itemStack.getTag().get(tag);
++                if (!Objects.equals(tag1, tag2)) {
++                    return false;
++                }
++            }
++        }
++        return true;
++        // Purpur end
+     }
+ 
+     private boolean allayConsidersItemEqual(ItemStack stack, ItemStack stack2) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 5b12c08a1d8e6f62c5653c95071a1d36d735d039..94e29919ddc7f507d54e14c3360f7a3e8bb831a7 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1138,10 +1138,13 @@ public class PurpurWorldConfig {
+     public boolean allayRidable = false;
+     public boolean allayRidableInWater = true;
+     public boolean allayControllable = true;
++    public List<String> allayRespectNBT = new ArrayList<>();
+     private void allaySettings() {
+         allayRidable = getBoolean("mobs.allay.ridable", allayRidable);
+         allayRidableInWater = getBoolean("mobs.allay.ridable-in-water", allayRidableInWater);
+         allayControllable = getBoolean("mobs.allay.controllable", allayControllable);
++        allayRespectNBT.clear();
++        getList("mobs.allay.respect-nbt", new ArrayList<>()).forEach(key -> allayRespectNBT.add(key.toString()));
+     }
+ 
+     public boolean axolotlRidable = false;

patches/server/outdated/purpur/0271-Add-item-packet-serialize-event.patch

@@ -0,0 +1,80 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MelnCat <melncatuwu@gmail.com>
+Date: Sat, 24 Sep 2022 09:56:28 -0700
+Subject: [PATCH] Add item packet serialize event
+
+
+diff --git a/src/main/java/net/minecraft/network/FriendlyByteBuf.java b/src/main/java/net/minecraft/network/FriendlyByteBuf.java
+index b863249ff7e13cf4939c8961601f0564c62fd661..bdcfd80f937c34956911373905d66424bbff8e1d 100644
+--- a/src/main/java/net/minecraft/network/FriendlyByteBuf.java
++++ b/src/main/java/net/minecraft/network/FriendlyByteBuf.java
+@@ -95,6 +95,8 @@ public class FriendlyByteBuf extends ByteBuf {
+     private static final int MAX_PUBLIC_KEY_LENGTH = 512;
+     private static final Gson GSON = new Gson();
+ 
++    public static boolean hasItemSerializeEvent = false; // Purpur
++
+     public FriendlyByteBuf(ByteBuf parent) {
+         this.source = parent;
+     }
+@@ -640,6 +642,17 @@ public class FriendlyByteBuf extends ByteBuf {
+             this.writeBoolean(false);
+         } else {
+             this.writeBoolean(true);
++            // Purpur start
++            if (hasItemSerializeEvent) {
++                var event = new org.purpurmc.purpur.event.packet.NetworkItemSerializeEvent(stack.asBukkitCopy());
++                event.callEvent();
++                ItemStack newStack = ItemStack.fromBukkitCopy(event.getItemStack());
++                if (org.purpurmc.purpur.PurpurConfig.fixNetworkSerializedItemsInCreative && !ItemStack.matches(stack, newStack)) {
++                    stack.save(newStack.getOrCreateTagElement("Purpur.OriginalItem"));
++                }
++                stack = newStack;
++            }
++            // Purpur end
+             Item item = stack.getItem();
+ 
+             this.writeId(BuiltInRegistries.ITEM, item);
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 4611116f3328c0f8d5b37c8765feca36b2448ffe..60b5e0643d933393b5473681ac9261db29fe2416 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1731,6 +1731,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         //MinecraftTimings.timeUpdateTimer.stopTiming(); // Spigot // Paper // Purpur
+ 
+         this.isIteratingOverLevels = true; // Paper - Throw exception on world create while being ticked
++        net.minecraft.network.FriendlyByteBuf.hasItemSerializeEvent = org.purpurmc.purpur.event.packet.NetworkItemSerializeEvent.getHandlerList().getRegisteredListeners().length > 0; // Purpur
+         Iterator iterator = this.getAllLevels().iterator(); // Paper - Throw exception on world create while being ticked; move down
+         while (iterator.hasNext()) {
+             ServerLevel worldserver = (ServerLevel) iterator.next();
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 872be72e24017fdcb3060f6e4e9a92c342d59fc1..f7ac60e1aa188ec25a4c5d326cdd4a109a54101c 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -3382,6 +3382,12 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+                     }
+                 }
+             }
++            // Purpur start
++            if (org.purpurmc.purpur.PurpurConfig.fixNetworkSerializedItemsInCreative) {
++                var tag = itemstack.getTagElement("Purpur.OriginalItem");
++                if (tag != null) itemstack = ItemStack.of(tag);
++            }
++            // Purpur end
+ 
+             boolean flag1 = packet.getSlotNum() >= 1 && packet.getSlotNum() <= 45;
+             boolean flag2 = itemstack.isEmpty() || itemstack.getDamageValue() >= 0 && itemstack.getCount() <= 64 && !itemstack.isEmpty();
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 5313ba91ffc625b27d5bb99395f0e719829f6bda..5329ad6493950a561bd46045e35a9bd70ac4405f 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -568,4 +568,9 @@ public class PurpurConfig {
+             }
+         });
+     }
++
++    public static boolean fixNetworkSerializedItemsInCreative = false;
++    private static void fixNetworkSerializedCreativeItems() {
++        fixNetworkSerializedItemsInCreative = getBoolean("settings.fix-network-serialized-items-in-creative", fixNetworkSerializedItemsInCreative);
++    }
+ }

patches/server/outdated/purpur/0282-Add-mending-multiplier.patch

@@ -0,0 +1,48 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: rafaelflromao <12960698+rafaelflromao@users.noreply.github.com>
+Date: Mon, 8 May 2023 20:43:29 +0100
+Subject: [PATCH] Add mending multiplier
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+index 7130d483ccdce26526e715bd7e68d2e896e6215f..40d168d225932717b8ac8bdd27dfe2a202bc2808 100644
+--- a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
++++ b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+@@ -372,13 +372,15 @@ public class ExperienceOrb extends Entity {
+         }
+     }
+ 
++    // Purpur start
+     public int durabilityToXp(int repairAmount) {
+-        return repairAmount / 2;
++        return (int) (repairAmount / (2 * level().purpurConfig.mendingMultiplier));
+     }
+ 
+     public int xpToDurability(int experienceAmount) {
+-        return experienceAmount * 2;
++        return (int) ((experienceAmount * 2) * level().purpurConfig.mendingMultiplier);
+     }
++    // Purpur end
+ 
+     public int getValue() {
+         return this.value;
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 02b8333222668c3419296ec5513c1c4e8e8d1a79..3c614b8f62c0d3839ebc4e948c952d52c4f66819 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -119,6 +119,7 @@ public class PurpurWorldConfig {
+     }
+ 
+     public boolean useBetterMending = false;
++    public double mendingMultiplier = 1.0;
+     public boolean alwaysTameInCreative = false;
+     public boolean boatEjectPlayersOnLand = false;
+     public boolean boatsDoFallDamage = false;
+@@ -147,6 +148,7 @@ public class PurpurWorldConfig {
+     public int mobLastHurtByPlayerTime = 100;
+     private void miscGameplayMechanicsSettings() {
+         useBetterMending = getBoolean("gameplay-mechanics.use-better-mending", useBetterMending);
++        mendingMultiplier = getDouble("gameplay-mechanics.mending-multiplier", mendingMultiplier);
+         alwaysTameInCreative = getBoolean("gameplay-mechanics.always-tame-in-creative", alwaysTameInCreative);
+         boatEjectPlayersOnLand = getBoolean("gameplay-mechanics.boat.eject-players-on-land", boatEjectPlayersOnLand);
+         boatsDoFallDamage = getBoolean("gameplay-mechanics.boat.do-fall-damage", boatsDoFallDamage);

patches/server/outdated/purpur/0292-Add-hover-lines-API.patch

@@ -0,0 +1,28 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Meln Cat <melncatuwu@gmail.com>
+Date: Mon, 2 Oct 2023 17:42:26 -0700
+Subject: [PATCH] Add hover lines API
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java
+index 6e2a6ce5cf456bd9f6c8c18a58f08e2285dc77ed..b27d16e74c3f99aa693b38590c1fb62db8204509 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java
+@@ -619,4 +619,17 @@ public final class CraftItemFactory implements ItemFactory {
+         return CraftItemStack.asCraftMirror(enchanted);
+     }
+     // Paper end - enchantWithLevels API
++
++    // Purpur start
++    @Override
++    public @org.jetbrains.annotations.NotNull java.util.List<net.kyori.adventure.text.@org.jetbrains.annotations.NotNull Component> getHoverLines(@org.jetbrains.annotations.NotNull ItemStack itemStack, boolean advanced) {
++        return io.papermc.paper.adventure.PaperAdventure.asAdventure(
++            CraftItemStack.asNMSCopy(itemStack).getTooltipLines(
++            null,
++            advanced ? net.minecraft.world.item.TooltipFlag.ADVANCED
++                : net.minecraft.world.item.TooltipFlag.NORMAL
++            )
++        );
++    }
++    // Purpur end
+ }