301

patches/server/Add-PlayerConnectionCloseEvent.patch

@@ -79,5 +79,5 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -    private GameProfile authenticatedProfile;
 +    public GameProfile authenticatedProfile; // Paper - public
      private final String serverId;
+     private final boolean transferred;
      private ServerPlayer player; // CraftBukkit
- 

patches/server/Add-more-Witch-API.patch

@@ -13,9 +13,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class Witch extends Raider implements RangedAttackMob {
                  }
  
-                 if (potionregistry != null) {
+                 if (holder != null) {
 -                    // Paper start
--                    ItemStack potion = PotionUtils.setPotion(new ItemStack(Items.POTION), potionregistry);
+-                    ItemStack potion = PotionContents.createItemStack(Items.POTION, holder);
 -                    potion = org.bukkit.craftbukkit.event.CraftEventFactory.handleWitchReadyPotionEvent(this, potion);
 -                    this.setItemSlot(EquipmentSlot.MAINHAND, potion);
 -                    // Paper end
@@ -27,9 +27,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -
 -                    AttributeInstance attributemodifiable = this.getAttribute(Attributes.MOVEMENT_SPEED);
 -
--                    attributemodifiable.removeModifier(Witch.SPEED_MODIFIER_DRINKING.getId());
+-                    attributemodifiable.removeModifier(Witch.SPEED_MODIFIER_DRINKING.id());
 -                    attributemodifiable.addTransientModifier(Witch.SPEED_MODIFIER_DRINKING);
-+                    this.setDrinkingPotion(PotionUtils.setPotion(new ItemStack(Items.POTION), potionregistry)); // Paper - logic moved into setDrinkingPotion, copy exact impl into the method and then comment out
++                    this.setDrinkingPotion(PotionContents.createItemStack(Items.POTION, holder)); // Paper - logic moved into setDrinkingPotion, copy exact impl into the method and then comment out
                  }
              }
  
@@ -49,7 +49,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +        AttributeInstance attributemodifiable = this.getAttribute(Attributes.MOVEMENT_SPEED);
 +
-+        attributemodifiable.removeModifier(Witch.SPEED_MODIFIER_DRINKING.getId());
++        attributemodifiable.removeModifier(Witch.SPEED_MODIFIER_DRINKING.id());
 +        attributemodifiable.addTransientModifier(Witch.SPEED_MODIFIER_DRINKING);
 +    }
 +    // Paper end

patches/server/Add-option-to-prevent-players-from-moving-into-unloa.patch

@@ -63,5 +63,5 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                                }
 +                                // Paper end - Prevent moving into unloaded chunks
  
-                                 if (!this.player.isChangingDimension() && (!this.player.level().getGameRules().getBoolean(GameRules.RULE_DISABLE_ELYTRA_MOVEMENT_CHECK) || !this.player.isFallFlying())) {
-                                     float f2 = this.player.isFallFlying() ? 300.0F : 100.0F;
+                                 if (!this.player.isChangingDimension() && (!this.player.level().getGameRules().getBoolean(GameRules.RULE_DISABLE_ELYTRA_MOVEMENT_CHECK) || !flag)) {
+                                     float f2 = flag ? 300.0F : 100.0F;

patches/server/BlockDestroyEvent.patch

@@ -14,7 +14,7 @@ diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/Level.java
 +++ b/src/main/java/net/minecraft/world/level/Level.java
-@@ -0,0 +0,0 @@ import net.minecraft.nbt.CompoundTag;
+@@ -0,0 +0,0 @@ import net.minecraft.core.registries.Registries;
  import net.minecraft.network.protocol.Packet;
  import net.minecraft.resources.ResourceKey;
  import net.minecraft.resources.ResourceLocation;

patches/server/Brigadier-Mojang-API.patch

@@ -144,23 +144,31 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            com.destroystokyo.paper.event.brigadier.AsyncPlayerSendSuggestionsEvent suggestEvent = new com.destroystokyo.paper.event.brigadier.AsyncPlayerSendSuggestionsEvent(this.getCraftPlayer(), suggestions, packet.getCommand());
 +            suggestEvent.setCancelled(suggestions.isEmpty());
 +            if (suggestEvent.callEvent()) {
-+                this.connection.send(new ClientboundCommandSuggestionsPacket(packet.getId(), suggestEvent.getSuggestions()));
++                this.connection.send(new ClientboundCommandSuggestionsPacket(packet.getId(), limitTo(suggestEvent.getSuggestions(), ServerGamePacketListenerImpl.MAX_COMMAND_SUGGESTIONS)));
 +            }
 +            // Paper end - Brigadier API
          }
      }
++    // Paper start - brig API
++    private static Suggestions limitTo(final Suggestions suggestions, final int size) {
++        return suggestions.getList().size() <= size ? suggestions : new Suggestions(suggestions.getRange(), suggestions.getList().subList(0, size));
++    }
++    // Paper end - brig API
  
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+     private void sendServerSuggestions(final ServerboundCommandSuggestionPacket packet, final StringReader stringreader) {
+         // Paper end - AsyncTabCompleteEvent
          ParseResults<CommandSourceStack> parseresults = this.server.getCommands().getDispatcher().parse(stringreader, this.player.createCommandSourceStack());
  
          this.server.getCommands().getDispatcher().getCompletionSuggestions(parseresults).thenAccept((suggestions) -> {
 -            if (suggestions.isEmpty()) return; // CraftBukkit - don't send through empty suggestions - prevents [<args>] from showing for plugins with nothing more to offer
--            this.send(new ClientboundCommandSuggestionsPacket(packet.getId(), suggestions));
+-            Suggestions suggestions1 = suggestions.getList().size() <= 1000 ? suggestions : new Suggestions(suggestions.getRange(), suggestions.getList().subList(0, 1000));
+-
+-            this.send(new ClientboundCommandSuggestionsPacket(packet.getId(), suggestions1));
 +            // Paper start - Brigadier API
 +            com.destroystokyo.paper.event.brigadier.AsyncPlayerSendSuggestionsEvent suggestEvent = new com.destroystokyo.paper.event.brigadier.AsyncPlayerSendSuggestionsEvent(this.getCraftPlayer(), suggestions, packet.getCommand());
 +            suggestEvent.setCancelled(suggestions.isEmpty());
 +            if (suggestEvent.callEvent()) {
-+                this.send(new ClientboundCommandSuggestionsPacket(packet.getId(), suggestEvent.getSuggestions()));
++                this.send(new ClientboundCommandSuggestionsPacket(packet.getId(), limitTo(suggestEvent.getSuggestions(), ServerGamePacketListenerImpl.MAX_COMMAND_SUGGESTIONS)));
 +            }
 +            // Paper end - Brigadier API
          });

patches/server/Catch-JsonParseException-in-entity-and-block-entity-.patch

@@ -22,13 +22,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
 +
 +    @Nullable
-+    public static net.minecraft.network.chat.Component getBaseComponentFromNbt(String key, net.minecraft.nbt.CompoundTag compound) {
++    public static net.minecraft.network.chat.Component getBaseComponentFromNbt(final String key, final net.minecraft.nbt.CompoundTag compound, final net.minecraft.core.HolderLookup.Provider lookupProvider) {
 +        if (!compound.contains(key)) {
 +            return null;
 +        }
-+        String string = compound.getString(key);
++        final String string = compound.getString(key);
 +        try {
-+            return net.minecraft.network.chat.Component.Serializer.fromJson(string);
++            return net.minecraft.network.chat.Component.Serializer.fromJson(string, lookupProvider);
 +        } catch (com.google.gson.JsonParseException e) {
 +            org.bukkit.Bukkit.getLogger().warning("Unable to parse " + key + " from " + compound +": " + e.getMessage());
 +        }
@@ -44,34 +44,34 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          this.command = nbt.getString("Command");
          this.successCount = nbt.getInt("SuccessCount");
          if (nbt.contains("CustomName", 8)) {
--            this.setName(Component.Serializer.fromJson(nbt.getString("CustomName")));
-+            this.setName(io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt)); // Paper - Catch ParseException
+-            this.setCustomName(Component.Serializer.fromJson(nbt.getString("CustomName"), registries));
++            this.setCustomName(io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt, registries)); // Paper - Catch ParseException
+         } else {
+             this.setCustomName((Component) null);
          }
- 
-         if (nbt.contains("TrackOutput", 1)) {
 diff --git a/src/main/java/net/minecraft/world/level/block/entity/BannerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BannerBlockEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/entity/BannerBlockEntity.java
 +++ b/src/main/java/net/minecraft/world/level/block/entity/BannerBlockEntity.java
 @@ -0,0 +0,0 @@ public class BannerBlockEntity extends BlockEntity implements Nameable {
-     public void load(CompoundTag nbt) {
-         super.load(nbt);
+     protected void loadAdditional(CompoundTag nbt, HolderLookup.Provider registryLookup) {
+         super.loadAdditional(nbt, registryLookup);
          if (nbt.contains("CustomName", 8)) {
--            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"));
-+            this.name = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt); // Paper - Catch ParseException
+-            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"), registryLookup);
++            this.name = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt, registryLookup); // Paper - Catch ParseException
          }
  
-         this.itemPatterns = nbt.getList("Patterns", 10);
+         if (nbt.contains("patterns")) {
 diff --git a/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
 +++ b/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
 @@ -0,0 +0,0 @@ public abstract class BaseContainerBlockEntity extends BlockEntity implements Co
-         super.load(nbt);
+         super.loadAdditional(nbt, registryLookup);
          this.lockKey = LockCode.fromTag(nbt);
          if (nbt.contains("CustomName", 8)) {
--            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"));
-+            this.name = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt); // Paper - Catch ParseException
+-            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"), registryLookup);
++            this.name = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt, registryLookup); // Paper - Catch ParseException
          }
  
      }
@@ -83,21 +83,34 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          this.secondaryPower = BeaconBlockEntity.loadEffect(nbt, "secondary_effect");
          this.levels = nbt.getInt("Levels"); // CraftBukkit - SPIGOT-5053, use where available
          if (nbt.contains("CustomName", 8)) {
--            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"));
-+            this.name = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt); // Paper - Catch ParseException
+-            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"), registryLookup);
++            this.name = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt, registryLookup); // Paper - Catch ParseException
          }
  
          this.lockKey = LockCode.fromTag(nbt);
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/EnchantmentTableBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/EnchantmentTableBlockEntity.java
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/EnchantingTableBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/EnchantingTableBlockEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/EnchantmentTableBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/EnchantmentTableBlockEntity.java
-@@ -0,0 +0,0 @@ public class EnchantmentTableBlockEntity extends BlockEntity implements Nameable
-     public void load(CompoundTag nbt) {
-         super.load(nbt);
+--- a/src/main/java/net/minecraft/world/level/block/entity/EnchantingTableBlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/EnchantingTableBlockEntity.java
+@@ -0,0 +0,0 @@ public class EnchantingTableBlockEntity extends BlockEntity implements Nameable
+     protected void loadAdditional(CompoundTag nbt, HolderLookup.Provider registryLookup) {
+         super.loadAdditional(nbt, registryLookup);
          if (nbt.contains("CustomName", 8)) {
--            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"));
-+            this.name = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt); // Paper - Catch ParseException
+-            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"), registryLookup);
++            this.name = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt, registryLookup); // Paper - Catch ParseException
          }
      }
  
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java
+@@ -0,0 +0,0 @@ public class SkullBlockEntity extends BlockEntity {
+         }
+ 
+         if (nbt.contains("custom_name", 8)) {
+-            this.customName = Component.Serializer.fromJson(nbt.getString("custom_name"), registryLookup);
++            this.customName = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("custom_name", nbt, registryLookup); // Paper - Catch ParseException
+         } else {
+             this.customName = null;
+         }

patches/server/Configurable-connection-throttle-kick-message.patch

@@ -9,11 +9,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
 +++ b/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
 @@ -0,0 +0,0 @@ public class ServerHandshakePacketListenerImpl implements ServerHandshakePacketL
-                     synchronized (ServerHandshakePacketListenerImpl.throttleTracker) {
-                         if (ServerHandshakePacketListenerImpl.throttleTracker.containsKey(address) && !"127.0.0.1".equals(address.getHostAddress()) && currentTime - ServerHandshakePacketListenerImpl.throttleTracker.get(address) < connectionThrottle) {
-                             ServerHandshakePacketListenerImpl.throttleTracker.put(address, currentTime);
--                            MutableComponent chatmessage = Component.literal("Connection throttled! Please wait before reconnecting.");
+             synchronized (ServerHandshakePacketListenerImpl.throttleTracker) {
+                 if (ServerHandshakePacketListenerImpl.throttleTracker.containsKey(address) && !"127.0.0.1".equals(address.getHostAddress()) && currentTime - ServerHandshakePacketListenerImpl.throttleTracker.get(address) < connectionThrottle) {
+                     ServerHandshakePacketListenerImpl.throttleTracker.put(address, currentTime);
+-                    MutableComponent chatmessage = Component.literal("Connection throttled! Please wait before reconnecting.");
 +                            Component chatmessage = io.papermc.paper.adventure.PaperAdventure.asVanilla(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.connectionThrottle); // Paper - Configurable connection throttle kick message
-                             this.connection.send(new ClientboundLoginDisconnectPacket(chatmessage));
-                             this.connection.disconnect(chatmessage);
-                             return;
+                     this.connection.send(new ClientboundLoginDisconnectPacket(chatmessage));
+                     this.connection.disconnect(chatmessage);
+                     return;

patches/server/Don-t-allow-digging-into-unloaded-chunks.patch

@@ -37,7 +37,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
  
      public void handleBlockBreakAction(BlockPos pos, ServerboundPlayerActionPacket.Action action, Direction direction, int worldHeight, int sequence) {
-         if (this.player.getEyePosition().distanceToSqr(Vec3.atCenterOf(pos)) > ServerGamePacketListenerImpl.MAX_INTERACTION_DISTANCE) {
+         if (!this.player.canInteractWithBlock(pos, 1.0D)) {
 +            if (true) return; // Paper - Don't allow digging into unloaded chunks; Don't notify if unreasonably far away
              this.debugLogging(pos, false, sequence, "too far");
          } else if (pos.getY() >= worldHeight) {

patches/server/Entity-getEntitySpawnReason.patch

@@ -50,19 +50,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          String s1 = connection.getLoggableAddress(this.server.logIPs());
  
 @@ -0,0 +0,0 @@ public abstract class PlayerList {
-             // CraftBukkit start
-             ServerLevel finalWorldServer = worldserver1;
-             Entity entity = EntityType.loadEntityRecursive(nbttagcompound1.getCompound("Entity"), finalWorldServer, (entity1) -> {
--                return !finalWorldServer.addWithUUID(entity1) ? null : entity1;
-+                return !finalWorldServer.addWithUUID(entity1, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.MOUNT) ? null : entity1; // Paper - Entity#getEntitySpawnReason
-                 // CraftBukkit end
+             CompoundTag nbttagcompound = ((CompoundTag) optional.get()).getCompound("RootVehicle");
+             ServerLevel finalWorldServer = worldserver1; // CraftBukkit - decompile error
+             Entity entity = EntityType.loadEntityRecursive(nbttagcompound.getCompound("Entity"), worldserver1, (entity1) -> {
+-                return !finalWorldServer.addWithUUID(entity1) ? null : entity1; // CraftBukkit - decompile error
++                return !finalWorldServer.addWithUUID(entity1, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.MOUNT) ? null : entity1; // CraftBukkit - decompile error // Paper - Entity#getEntitySpawnReason
              });
  
+             if (entity != null) {
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          }
      }
      // Paper end - Share random for entities to make them more random
@@ -70,7 +70,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public com.destroystokyo.paper.loottable.PaperLootableInventoryData lootableData; // Paper
      private CraftEntity bukkitEntity;
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
                  }
                  nbttagcompound.put("Paper.Origin", this.newDoubleList(origin.getX(), origin.getY(), origin.getZ()));
              }
@@ -80,7 +80,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              // Save entity's from mob spawner status
              if (spawnedViaMobSpawner) {
                  nbttagcompound.putBoolean("Paper.FromMobSpawner", true);
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
              }
  
              spawnedViaMobSpawner = nbt.getBoolean("Paper.FromMobSpawner"); // Restore entity's from mob spawner status

patches/server/Honor-EntityAgeable.ageLock.patch

@@ -21,18 +21,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
 +++ b/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
 @@ -0,0 +0,0 @@ public class BeehiveBlockEntity extends BlockEntity {
-     }
- 
-     private static void setBeeReleaseData(int ticks, Bee bee) {
-+        if (!bee.ageLocked) { // Paper - Honor ageLock
-         int j = bee.getAge();
- 
-         if (j < 0) {
-@@ -0,0 +0,0 @@ public class BeehiveBlockEntity extends BlockEntity {
-         } else if (j > 0) {
-             bee.setAge(Math.max(0, j - ticks));
          }
-+        } // Paper - Honor ageLock
  
-         bee.setInLoveTime(Math.max(0, bee.getInLoveTime() - ticks));
+         private static void setBeeReleaseData(int ticksInHive, Bee beeEntity) {
++            if (!beeEntity.ageLocked) { // Paper - Honor ageLock
+             int j = beeEntity.getAge();
+ 
+             if (j < 0) {
+@@ -0,0 +0,0 @@ public class BeehiveBlockEntity extends BlockEntity {
+             }
+ 
+             beeEntity.setInLoveTime(Math.max(0, beeEntity.getInLoveTime() - ticksInHive));
++            } // Paper - Honor ageLock
+         }
      }
+ 

patches/server/Implement-furnace-cook-speed-multiplier-API.patch

@@ -19,6 +19,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    public double cookSpeedMultiplier = 1.0; // Paper - cook speed multiplier API
      public int cookingProgress;
      public int cookingTotalTime;
+     @Nullable
+@@ -0,0 +0,0 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
      protected final ContainerData dataAccess;
      public final Object2IntOpenHashMap<ResourceLocation> recipesUsed;
      private final RecipeManager.CachedCheck<Container, ? extends AbstractCookingRecipe> quickCheck;
@@ -33,7 +35,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this.recipeType = recipeType; // Paper - cook speed multiplier API
      }
  
-     public static Map<Item, Integer> getFuel() {
+     public static void invalidateCache() {
 @@ -0,0 +0,0 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
              this.recipesUsed.put(new ResourceLocation(s), nbttagcompound1.getInt(s));
          }
@@ -51,7 +53,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          nbt.putShort("CookTime", (short) this.cookingProgress);
          nbt.putShort("CookTimeTotal", (short) this.cookingTotalTime);
 +        nbt.putDouble("Paper.CookSpeedMultiplier", this.cookSpeedMultiplier); // Paper - cook speed multiplier API
-         ContainerHelper.saveAllItems(nbt, this.items);
+         ContainerHelper.saveAllItems(nbt, this.items, registryLookup);
          CompoundTag nbttagcompound1 = new CompoundTag();
  
 @@ -0,0 +0,0 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
@@ -94,8 +96,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public static boolean isFuel(ItemStack stack) {
 @@ -0,0 +0,0 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
-         }
- 
+         this.items.set(slot, stack);
+         stack.limitSize(this.getMaxStackSize(stack));
          if (slot == 0 && !flag) {
 -            this.cookingTotalTime = AbstractFurnaceBlockEntity.getTotalCookTime(this.level, this);
 +            this.cookingTotalTime = AbstractFurnaceBlockEntity.getTotalCookTime(this.level, this.recipeType, this, this.cookSpeedMultiplier); // Paper - cook speed multiplier API
@@ -109,7 +111,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public abstract class CraftFurnace<T extends AbstractFurnaceBlockEntity> extends
  
      @Override
-     public abstract CraftFurnace<T> copy();
+     public abstract CraftFurnace<T> copy(Location location);
 +
 +    // Paper start - cook speed multiplier API
 +    @Override

patches/server/Improve-exact-choice-recipe-ingredients.patch

@@ -93,7 +93,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                    final IntList idList = new IntArrayList(items.length);
 +                    for (final ItemStack item : items) {
 +                        idList.add(this.registerExact(item)); // I think not copying the stack here is safe because cb copies the stack when creating the ingredient
-+                        if (!item.hasTag()) {
++                        if (item.getComponentsPatch().isEmpty()) {
 +                            // add regular index if it's a plain itemstack but still registered as exact
 +                            idList.add(StackedContents.getStackingIndex(item));
 +                        }
@@ -158,11 +158,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              int l = k;
  
              for (int m : intList) {
--                int n = StackedContents.fromStackingIndex(m).getMaxStackSize();
-+                int n = StackedContents.maxStackSizeFromStackingIndex(m, this.stackedContents); // Paper - Improve exact choice recipe ingredients
-                 if (n < l) {
-                     l = n;
-                 }
+-                ItemStack itemStack2 = StackedContents.fromStackingIndex(m);
++                ItemStack itemStack2 = StackedContents.fromStackingIndexWithExtras(m, this.stackedContents); // Paper - Improve exact choice recipe ingredients
+                 if (!itemStack2.isEmpty()) {
+                     int n = itemStack2.getMaxStackSize();
+                     if (n < l) {
 @@ -0,0 +0,0 @@ public class ServerPlaceRecipe<C extends Container> implements PlaceRecipe<Integ
      @Override
      public void addItemToSlot(Iterator<Integer> inputs, int slot, int amount, int gridX, int gridY) {
@@ -214,15 +214,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @Nullable public io.papermc.paper.inventory.recipe.StackedContentsExtraMap extrasMap = null; // Paper - Improve exact choice recipe ingredients
  
      public void accountSimpleStack(ItemStack stack) {
-+        if (this.extrasMap != null && stack.hasTag() && this.extrasMap.accountStack(stack, Math.min(64, stack.getCount()))) return; // Paper - Improve exact choice recipe ingredients; max of 64 due to accountStack method below
-         if (!stack.isDamaged() && !stack.isEnchanted() && !stack.hasCustomHoverName()) {
++        if (this.extrasMap != null && !stack.getComponentsPatch().isEmpty() && this.extrasMap.accountStack(stack, Math.min(64, stack.getCount()))) return; // Paper - Improve exact choice recipe ingredients; max of 64 due to accountStack method below
+         if (!stack.isDamaged() && !stack.isEnchanted() && !stack.has(DataComponents.CUSTOM_NAME)) {
              this.accountStack(stack);
          }
 @@ -0,0 +0,0 @@ public class StackedContents {
          if (!stack.isEmpty()) {
              int i = getStackingIndex(stack);
              int j = Math.min(maxCount, stack.getCount());
-+            if (this.extrasMap != null && stack.hasTag() && this.extrasMap.accountStack(stack, j)) return; // Paper - Improve exact choice recipe ingredients; if an exact ingredient, don't include it
++            if (this.extrasMap != null && !stack.getComponentsPatch().isEmpty() && this.extrasMap.accountStack(stack, j)) return; // Paper - Improve exact choice recipe ingredients; if an exact ingredient, don't include it
              this.put(i, j);
          }
      }
@@ -235,11 +235,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this.extrasMap = new io.papermc.paper.inventory.recipe.StackedContentsExtraMap(this, recipe);
 +    }
 +
-+    public static int maxStackSizeFromStackingIndex(final int itemId, @Nullable final StackedContents contents) {
++    public static ItemStack fromStackingIndexWithExtras(final int itemId, @Nullable final StackedContents contents) {
 +        if (contents != null && contents.extrasMap != null && itemId >= BuiltInRegistries.ITEM.size()) {
-+            return fromStackingIndexExtras(itemId, contents.extrasMap).getMaxStackSize();
++            return fromStackingIndexExtras(itemId, contents.extrasMap);
 +        }
-+        return fromStackingIndex(itemId).getMaxStackSize();
++        return fromStackingIndex(itemId);
 +    }
 +
 +    public static ItemStack fromStackingIndexExtras(final int itemId, final io.papermc.paper.inventory.recipe.StackedContentsExtraMap extrasMap) {

patches/server/Mob-Spawner-API-Enhancements.patch

@@ -73,8 +73,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/block/CraftCreatureSpawner.java
 +++ b/src/main/java/org/bukkit/craftbukkit/block/CraftCreatureSpawner.java
 @@ -0,0 +0,0 @@ public class CraftCreatureSpawner extends CraftBlockEntityState<SpawnerBlockEnti
-     public CraftCreatureSpawner copy() {
-         return new CraftCreatureSpawner(this);
+                 new HashMap<>(nms.slotDropChances().entrySet().stream().collect(Collectors.toMap((entry) -> CraftEquipmentSlot.getSlot(entry.getKey()), Map.Entry::getValue)))
+         )).orElse(null);
      }
 +
 +    // Paper start

patches/server/Prevent-various-interactions-from-causing-chunk-load.patch

@@ -63,19 +63,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              Vec3 vec3d = new Vec3((double) this.enderman.getBlockX() + 0.5D, (double) j + 0.5D, (double) this.enderman.getBlockZ() + 0.5D);
              Vec3 vec3d1 = new Vec3((double) i + 0.5D, (double) j + 0.5D, (double) k + 0.5D);
              BlockHitResult movingobjectpositionblock = world.clip(new ClipContext(vec3d, vec3d1, ClipContext.Block.OUTLINE, ClipContext.Fluid.NONE, this.enderman));
-diff --git a/src/main/java/net/minecraft/world/item/CompassItem.java b/src/main/java/net/minecraft/world/item/CompassItem.java
+diff --git a/src/main/java/net/minecraft/world/item/component/LodestoneTracker.java b/src/main/java/net/minecraft/world/item/component/LodestoneTracker.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/CompassItem.java
-+++ b/src/main/java/net/minecraft/world/item/CompassItem.java
-@@ -0,0 +0,0 @@ public class CompassItem extends Item implements Vanishable {
-                 Optional<ResourceKey<Level>> optional = getLodestoneDimension(compoundTag);
-                 if (optional.isPresent() && optional.get() == world.dimension() && compoundTag.contains("LodestonePos")) {
-                     BlockPos blockPos = NbtUtils.readBlockPos(compoundTag.getCompound("LodestonePos"));
--                    if (!world.isInWorldBounds(blockPos) || !((ServerLevel)world).getPoiManager().existsAtPosition(PoiTypes.LODESTONE, blockPos)) {
-+                    if (!world.isInWorldBounds(blockPos) || (world.hasChunkAt(blockPos) && !((ServerLevel)world).getPoiManager().existsAtPosition(PoiTypes.LODESTONE, blockPos))) { // Paper - Prevent compass from loading chunks
-                         compoundTag.remove("LodestonePos");
-                     }
-                 }
+--- a/src/main/java/net/minecraft/world/item/component/LodestoneTracker.java
++++ b/src/main/java/net/minecraft/world/item/component/LodestoneTracker.java
+@@ -0,0 +0,0 @@ public record LodestoneTracker(Optional<GlobalPos> target, boolean tracked) {
+                 return this;
+             } else {
+                 BlockPos blockPos = this.target.get().pos();
+-                return world.isInWorldBounds(blockPos) && world.getPoiManager().existsAtPosition(PoiTypes.LODESTONE, blockPos)
++                return world.isInWorldBounds(blockPos) && (!world.hasChunkAt(blockPos) || world.getPoiManager().existsAtPosition(PoiTypes.LODESTONE, blockPos)) // Paper - Prevent compass from loading chunks
+                     ? this
+                     : new LodestoneTracker(Optional.empty(), true);
+             }
 diff --git a/src/main/java/net/minecraft/world/level/BlockGetter.java b/src/main/java/net/minecraft/world/level/BlockGetter.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/BlockGetter.java

patches/server/Replace-OfflinePlayer-getLastPlayed.patch

@@ -38,7 +38,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        player.loginTime = System.currentTimeMillis(); // Paper - Replace OfflinePlayer#getLastPlayed
          GameProfile gameprofile = player.getGameProfile();
          GameProfileCache usercache = this.server.getProfileCache();
-         String s;
+         // Optional optional; // CraftBukkit - decompile error
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java b/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java

patches/server/Restore-custom-InventoryHolder-support.patch

@@ -275,7 +275,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      // Paper end
  
 @@ -0,0 +0,0 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat
-             ((RandomizableContainerBlockEntity) te).setCustomName(CraftChatMessage.fromStringOrNull(title));
+             ((RandomizableContainerBlockEntity) te).name = CraftChatMessage.fromStringOrNull(title);
          }
  
 -        return this.getInventory(te);
@@ -306,7 +306,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat
          public Inventory createInventory(InventoryHolder owner, InventoryType type, String title) {
              Container tileEntity = this.getTileEntity();
-             ((AbstractFurnaceBlockEntity) tileEntity).setCustomName(CraftChatMessage.fromStringOrNull(title));
+             ((AbstractFurnaceBlockEntity) tileEntity).name = CraftChatMessage.fromStringOrNull(title);
 -            return this.getInventory(tileEntity);
 +            return this.getInventory(owner, type, tileEntity); // Paper
          }
@@ -335,7 +335,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 @@ -0,0 +0,0 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat
              if (tileEntity instanceof BrewingStandBlockEntity) {
-                 ((BrewingStandBlockEntity) tileEntity).setCustomName(CraftChatMessage.fromStringOrNull(title));
+                 ((BrewingStandBlockEntity) tileEntity).name = CraftChatMessage.fromStringOrNull(title);
              }
 -            return this.getInventory(tileEntity);
 +            return this.getInventory(holder, type, tileEntity); // Paper

patches/server/Turtle-API.patch

@@ -35,7 +35,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                    BlockState iblockdata = (BlockState) Blocks.TURTLE_EGG.defaultBlockState().setValue(TurtleEggBlock.EGGS, layEggEvent.getEggCount()); // Paper
  
                      world.setBlock(blockposition1, iblockdata, 3);
-                     world.gameEvent(GameEvent.BLOCK_PLACE, blockposition1, GameEvent.Context.of(this.turtle, iblockdata));
+                     world.gameEvent((Holder) GameEvent.BLOCK_PLACE, blockposition1, GameEvent.Context.of(this.turtle, iblockdata));
 @@ -0,0 +0,0 @@ public class Turtle extends Animal {
  
          @Override

patches/server/force-entity-dismount-during-teleportation.patch

@@ -23,7 +23,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/jav
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
      }
  
      public void removeVehicle() {
@@ -41,7 +41,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
  
      }
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          }
      }
  
@@ -53,7 +53,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (entity.getVehicle() == this) {
              throw new IllegalStateException("Use x.stopRiding(y), not y.removePassenger(x)");
          } else {
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
              if (this.getBukkitEntity() instanceof Vehicle && entity.getBukkitEntity() instanceof LivingEntity) {
                  VehicleExitEvent event = new VehicleExitEvent(
                          (Vehicle) this.getBukkitEntity(),
@@ -62,7 +62,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  );
                  // Suppress during worldgen
                  if (this.valid) {
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
                  }
              }
  

patches/unapplied/server/Add-API-for-CanPlaceOn-and-CanDestroy-NBT-values.patch

@@ -1,397 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mark Vainomaa <mikroskeem@mikroskeem.eu>
-Date: Wed, 12 Sep 2018 18:53:55 +0300
-Subject: [PATCH] Add API for CanPlaceOn and CanDestroy NBT values
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
-@@ -0,0 +0,0 @@ import org.bukkit.persistence.PersistentDataContainer;
- import static org.spigotmc.ValidateUtils.*;
- // Spigot end
- 
-+// Paper start
-+import com.destroystokyo.paper.Namespaced;
-+import com.destroystokyo.paper.NamespacedTag;
-+import java.util.Collections;
-+// Paper end
-+
- /**
-  * Children must include the following:
-  *
-@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
-     @Specific(Specific.To.NBT)
-     static final ItemMetaKey BLOCK_DATA = new ItemMetaKey("BlockStateTag");
-     static final ItemMetaKey BUKKIT_CUSTOM_TAG = new ItemMetaKey("PublicBukkitValues");
-+    // Paper start - Add API for CanPlaceOn and CanDestroy NBT values
-+    static final ItemMetaKey CAN_DESTROY = new ItemMetaKey("CanDestroy");
-+    static final ItemMetaKey CAN_PLACE_ON = new ItemMetaKey("CanPlaceOn");
-+    // Paper end - Add API for CanPlaceOn and CanDestroy NBT values
- 
-     // We store the raw original JSON representation of all text data. See SPIGOT-5063, SPIGOT-5656, SPIGOT-5304
-     private String displayName;
-@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
-     private int hideFlag;
-     private boolean unbreakable;
-     private int damage;
-+    // Paper start - Add API for CanPlaceOn and CanDestroy NBT values
-+    private Set<Namespaced> placeableKeys = Sets.newHashSet();
-+    private Set<Namespaced> destroyableKeys = Sets.newHashSet();
-+    // Paper end - Add API for CanPlaceOn and CanDestroy NBT values
- 
-     private static final Set<String> HANDLED_TAGS = Sets.newHashSet();
-     private static final CraftPersistentDataTypeRegistry DATA_TYPE_REGISTRY = new CraftPersistentDataTypeRegistry();
-@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
-         this.hideFlag = meta.hideFlag;
-         this.unbreakable = meta.unbreakable;
-         this.damage = meta.damage;
-+        // Paper start - Add API for CanPlaceOn and CanDestroy NBT values
-+        if (meta.hasPlaceableKeys()) {
-+            this.placeableKeys = new java.util.HashSet<>(meta.placeableKeys);
-+        }
-+
-+        if (meta.hasDestroyableKeys()) {
-+            this.destroyableKeys = new java.util.HashSet<>(meta.destroyableKeys);
-+        }
-+        // Paper end - Add API for CanPlaceOn and CanDestroy NBT values
-         this.unhandledTags.putAll(meta.unhandledTags);
-         this.persistentDataContainer.putAll(meta.persistentDataContainer.getRaw());
- 
-@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
-                 this.persistentDataContainer.put(key, compound.get(key).copy());
-             }
-         }
-+        // Paper start - Add API for CanPlaceOn and CanDestroy NBT values
-+        if (tag.contains(CAN_DESTROY.NBT)) {
-+            ListTag list = tag.getList(CAN_DESTROY.NBT, CraftMagicNumbers.NBT.TAG_STRING);
-+            for (int i = 0; i < list.size(); i++) {
-+                Namespaced namespaced = this.blockKeyFromString(list.getString(i));
-+                if (namespaced == null) {
-+                    continue;
-+                }
-+
-+                this.destroyableKeys.add(namespaced);
-+            }
-+        }
-+
-+        if (tag.contains(CAN_PLACE_ON.NBT)) {
-+            ListTag list = tag.getList(CAN_PLACE_ON.NBT, CraftMagicNumbers.NBT.TAG_STRING);
-+            for (int i = 0; i < list.size(); i++) {
-+                Namespaced namespaced = this.blockKeyFromString(list.getString(i));
-+                if (namespaced == null) {
-+                    continue;
-+                }
-+
-+                this.placeableKeys.add(namespaced);
-+            }
-+        }
-+        // Paper end - Add API for CanPlaceOn and CanDestroy NBT values
- 
-         Set<String> keys = tag.getAllKeys();
-         for (String key : keys) {
-@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
-             this.setDamage(damage);
-         }
- 
-+        // Paper start - Add API for CanPlaceOn and CanDestroy NBT values
-+        Iterable<?> canPlaceOnSerialized = SerializableMeta.getObject(Iterable.class, map, CAN_PLACE_ON.BUKKIT, true);
-+        if (canPlaceOnSerialized != null) {
-+            for (Object canPlaceOnElement : canPlaceOnSerialized) {
-+                String canPlaceOnRaw = (String) canPlaceOnElement;
-+                Namespaced value = this.blockKeyFromString(canPlaceOnRaw);
-+                if (value == null) {
-+                    continue;
-+                }
-+
-+                this.placeableKeys.add(value);
-+            }
-+        }
-+
-+        Iterable<?> canDestroySerialized = SerializableMeta.getObject(Iterable.class, map, CAN_DESTROY.BUKKIT, true);
-+        if (canDestroySerialized != null) {
-+            for (Object canDestroyElement : canDestroySerialized) {
-+                String canDestroyRaw = (String) canDestroyElement;
-+                Namespaced value = this.blockKeyFromString(canDestroyRaw);
-+                if (value == null) {
-+                    continue;
-+                }
-+
-+                this.destroyableKeys.add(value);
-+            }
-+        }
-+        // Paper end - Add API for CanPlaceOn and CanDestroy NBT values
-+
-         String internal = SerializableMeta.getString(map, "internal", true);
-         if (internal != null) {
-             ByteArrayInputStream buf = new ByteArrayInputStream(Base64.getDecoder().decode(internal));
-@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
-         if (this.hasDamage()) {
-             itemTag.putInt(CraftMetaItem.DAMAGE.NBT, this.damage);
-         }
-+        // Paper start - Add API for CanPlaceOn and CanDestroy NBT values
-+        if (hasPlaceableKeys()) {
-+            List<String> items = this.placeableKeys.stream()
-+                .map(this::serializeNamespaced)
-+                .collect(java.util.stream.Collectors.toList());
-+
-+            itemTag.put(CAN_PLACE_ON.NBT, createNonComponentStringList(items));
-+        }
-+
-+        if (hasDestroyableKeys()) {
-+            List<String> items = this.destroyableKeys.stream()
-+                .map(this::serializeNamespaced)
-+                .collect(java.util.stream.Collectors.toList());
-+
-+            itemTag.put(CAN_DESTROY.NBT, createNonComponentStringList(items));
-+        }
-+        // Paper end - Add API for CanPlaceOn and CanDestroy NBT values
- 
-         for (Map.Entry<String, Tag> e : this.unhandledTags.entrySet()) {
-             itemTag.put(e.getKey(), e.getValue());
-@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
-         }
-     }
- 
-+    // Paper start - Add API for CanPlaceOn and CanDestroy NBT values
-+    static ListTag createNonComponentStringList(List<String> list) {
-+        if (list == null || list.isEmpty()) {
-+            return null;
-+        }
-+
-+        ListTag tagList = new ListTag();
-+        for (String value : list) {
-+            tagList.add(StringTag.valueOf(value)); // Paper - NBTTagString.of(String str)
-+        }
-+
-+        return tagList;
-+    }
-+    // Paper end - Add API for CanPlaceOn and CanDestroy NBT values
-+
-     ListTag createStringList(List<String> list) {
-         if (list == null) {
-             return null;
-@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
- 
-     @Overridden
-     boolean isEmpty() {
--        return !(this.hasDisplayName() || this.hasLocalizedName() || this.hasEnchants() || (this.lore != null) || this.hasCustomModelData() || this.hasBlockData() || this.hasRepairCost() || !this.unhandledTags.isEmpty() || !this.persistentDataContainer.isEmpty() || this.hideFlag != 0 || this.isUnbreakable() || this.hasDamage() || this.hasAttributeModifiers());
-+        return !(this.hasDisplayName() || this.hasLocalizedName() || this.hasEnchants() || (this.lore != null) || this.hasCustomModelData() || this.hasBlockData() || this.hasRepairCost() || !this.unhandledTags.isEmpty() || !this.persistentDataContainer.isEmpty() || this.hideFlag != 0 || this.isUnbreakable() || this.hasDamage() || this.hasAttributeModifiers() || this.hasPlaceableKeys() || this.hasDestroyableKeys()); // Paper - Implement an API for CanPlaceOn and CanDestroy NBT values
-     }
- 
-     // Paper start
-@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
-                 && (this.hideFlag == that.hideFlag)
-                 && (this.isUnbreakable() == that.isUnbreakable())
-                 && (this.hasDamage() ? that.hasDamage() && this.damage == that.damage : !that.hasDamage())
--                && (this.version == that.version);
-+                && (this.version == that.version)
-+                // Paper start - Implement an API for CanPlaceOn and CanDestroy NBT values
-+                && (this.hasPlaceableKeys() ? that.hasPlaceableKeys() && this.placeableKeys.equals(that.placeableKeys) : !that.hasPlaceableKeys())
-+                && (this.hasDestroyableKeys() ? that.hasDestroyableKeys() && this.destroyableKeys.equals(that.destroyableKeys) : !that.hasDestroyableKeys());
-+                // Paper end
-     }
- 
-     /**
-@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
-         hash = 61 * hash + (this.hasDamage() ? this.damage : 0);
-         hash = 61 * hash + (this.hasAttributeModifiers() ? this.attributeModifiers.hashCode() : 0);
-         hash = 61 * hash + this.version;
-+        // Paper start - Implement an API for CanPlaceOn and CanDestroy NBT values
-+        hash = 61 * hash + (this.hasPlaceableKeys() ? this.placeableKeys.hashCode() : 0);
-+        hash = 61 * hash + (this.hasDestroyableKeys() ? this.destroyableKeys.hashCode() : 0);
-+        // Paper end
-         return hash;
-     }
- 
-@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
-             clone.unbreakable = this.unbreakable;
-             clone.damage = this.damage;
-             clone.version = this.version;
-+            // Paper start - Implement an API for CanPlaceOn and CanDestroy NBT values
-+            if (this.placeableKeys != null) {
-+                clone.placeableKeys = Sets.newHashSet(this.placeableKeys);
-+            }
-+            if (this.destroyableKeys != null) {
-+                clone.destroyableKeys = Sets.newHashSet(this.destroyableKeys);
-+            }
-+            // Paper end
-             return clone;
-         } catch (CloneNotSupportedException e) {
-             throw new Error(e);
-@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
-             builder.put(CraftMetaItem.DAMAGE.BUKKIT, this.damage);
-         }
- 
-+        // Paper start - Implement an API for CanPlaceOn and CanDestroy NBT values
-+        if (this.hasPlaceableKeys()) {
-+            List<String> cerealPlaceable = this.placeableKeys.stream()
-+                .map(this::serializeNamespaced)
-+                .collect(java.util.stream.Collectors.toList());
-+
-+            builder.put(CAN_PLACE_ON.BUKKIT, cerealPlaceable);
-+        }
-+
-+        if (this.hasDestroyableKeys()) {
-+            List<String> cerealDestroyable = this.destroyableKeys.stream()
-+                .map(this::serializeNamespaced)
-+                .collect(java.util.stream.Collectors.toList());
-+
-+            builder.put(CAN_DESTROY.BUKKIT, cerealDestroyable);
-+        }
-+        // Paper end
-         final Map<String, Tag> internalTags = new HashMap<String, Tag>(this.unhandledTags);
-         this.serializeInternal(internalTags);
-         if (!internalTags.isEmpty()) {
-@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
-                         CraftMetaArmorStand.SHOW_ARMS.NBT,
-                         CraftMetaArmorStand.SMALL.NBT,
-                         CraftMetaArmorStand.MARKER.NBT,
-+                        CAN_DESTROY.NBT,
-+                        CAN_PLACE_ON.NBT,
-                         // Paper end
-                         CraftMetaCompass.LODESTONE_DIMENSION.NBT,
-                         CraftMetaCompass.LODESTONE_POS.NBT,
-@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
-     }
-     // Paper end
- 
-+    // Paper start - Implement an API for CanPlaceOn and CanDestroy NBT values
-+    @Override
-+    @SuppressWarnings("deprecation")
-+    public Set<Material> getCanDestroy() {
-+        return !hasDestroyableKeys() ? Collections.emptySet() : legacyGetMatsFromKeys(this.destroyableKeys);
-+    }
-+
-+    @Override
-+    @SuppressWarnings("deprecation")
-+    public void setCanDestroy(Set<Material> canDestroy) {
-+        Preconditions.checkArgument(canDestroy != null, "Cannot replace with null set!");
-+        legacyClearAndReplaceKeys(this.destroyableKeys, canDestroy);
-+    }
-+
-+    @Override
-+    @SuppressWarnings("deprecation")
-+    public Set<Material> getCanPlaceOn() {
-+        return !hasPlaceableKeys() ? Collections.emptySet() : legacyGetMatsFromKeys(this.placeableKeys);
-+    }
-+
-+    @Override
-+    @SuppressWarnings("deprecation")
-+    public void setCanPlaceOn(Set<Material> canPlaceOn) {
-+        Preconditions.checkArgument(canPlaceOn != null, "Cannot replace with null set!");
-+        legacyClearAndReplaceKeys(this.placeableKeys, canPlaceOn);
-+    }
-+
-+    @Override
-+    public Set<Namespaced> getDestroyableKeys() {
-+        return !hasDestroyableKeys() ? Collections.emptySet() : Sets.newHashSet(this.destroyableKeys);
-+    }
-+
-+    @Override
-+    public void setDestroyableKeys(Collection<Namespaced> canDestroy) {
-+        Preconditions.checkArgument(canDestroy != null, "Cannot replace with null collection!");
-+        Preconditions.checkArgument(ofAcceptableType(canDestroy), "Can only use NamespacedKey or NamespacedTag objects!");
-+        this.destroyableKeys.clear();
-+        this.destroyableKeys.addAll(canDestroy);
-+    }
-+
-+    @Override
-+    public Set<Namespaced> getPlaceableKeys() {
-+        return !hasPlaceableKeys() ? Collections.emptySet() : Sets.newHashSet(this.placeableKeys);
-+    }
-+
-+    @Override
-+    public void setPlaceableKeys(Collection<Namespaced> canPlaceOn) {
-+        Preconditions.checkArgument(canPlaceOn != null, "Cannot replace with null collection!");
-+        Preconditions.checkArgument(ofAcceptableType(canPlaceOn), "Can only use NamespacedKey or NamespacedTag objects!");
-+        this.placeableKeys.clear();
-+        this.placeableKeys.addAll(canPlaceOn);
-+    }
-+
-+    @Override
-+    public boolean hasPlaceableKeys() {
-+        return this.placeableKeys != null && !this.placeableKeys.isEmpty();
-+    }
-+
-+    @Override
-+    public boolean hasDestroyableKeys() {
-+        return this.destroyableKeys != null && !this.destroyableKeys.isEmpty();
-+    }
-+
-+    @Deprecated
-+    private void legacyClearAndReplaceKeys(Collection<Namespaced> toUpdate, Collection<Material> beingSet) {
-+        if (beingSet.stream().anyMatch(Material::isLegacy)) {
-+            throw new IllegalArgumentException("Set must not contain any legacy materials!");
-+        }
-+
-+        toUpdate.clear();
-+        toUpdate.addAll(beingSet.stream().map(Material::getKey).collect(java.util.stream.Collectors.toSet()));
-+    }
-+
-+    @Deprecated
-+    private Set<Material> legacyGetMatsFromKeys(Collection<Namespaced> names) {
-+        Set<Material> mats = Sets.newHashSet();
-+        for (Namespaced key : names) {
-+            if (!(key instanceof org.bukkit.NamespacedKey)) {
-+                continue;
-+            }
-+
-+            Material material = Material.matchMaterial(key.toString(), false);
-+            if (material != null) {
-+                mats.add(material);
-+            }
-+        }
-+
-+        return mats;
-+    }
-+
-+    private @Nullable Namespaced blockKeyFromString(String raw) {
-+        boolean isTag = !raw.isEmpty() && raw.codePointAt(0) == '#';
-+        com.mojang.datafixers.util.Either<net.minecraft.commands.arguments.blocks.BlockStateParser.BlockResult, net.minecraft.commands.arguments.blocks.BlockStateParser.TagResult> result;
-+        try {
-+            result = net.minecraft.commands.arguments.blocks.BlockStateParser.parseForTesting(net.minecraft.core.registries.BuiltInRegistries.BLOCK.asLookup(), raw, false);
-+        } catch (com.mojang.brigadier.exceptions.CommandSyntaxException e) {
-+            return null;
-+        }
-+
-+        net.minecraft.resources.ResourceLocation key = null;
-+        if (isTag && result.right().isPresent() && result.right().get().tag() instanceof net.minecraft.core.HolderSet.Named<net.minecraft.world.level.block.Block> namedSet) {
-+            key = namedSet.key().location();
-+        } else if (result.left().isPresent()) {
-+            key = net.minecraft.core.registries.BuiltInRegistries.BLOCK.getKey(result.left().get().blockState().getBlock());
-+        }
-+
-+        if (key == null) {
-+            return null;
-+        }
-+
-+        try {
-+            if (isTag) {
-+                return new NamespacedTag(key.getNamespace(), key.getPath());
-+
-+            }
-+            return CraftNamespacedKey.fromMinecraft(key);
-+        } catch (IllegalArgumentException ignored) {
-+            return null;
-+        }
-+    }
-+
-+    private @Nonnull String serializeNamespaced(Namespaced resource) {
-+        return resource.toString();
-+    }
-+
-+    // not a fan of this
-+    private boolean ofAcceptableType(Collection<Namespaced> namespacedResources) {
-+        
-+        for (Namespaced resource : namespacedResources) {
-+            if (!(resource instanceof org.bukkit.NamespacedKey || resource instanceof com.destroystokyo.paper.NamespacedTag)) {
-+                return false;
-+            }
-+        }
-+
-+        return true;
-+    }
-+    // Paper end
- }

patches/unapplied/server/Configurable-Keep-Spawn-Loaded-range-per-world.patch

@@ -1,220 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sat, 13 Sep 2014 23:14:43 -0400
-Subject: [PATCH] Configurable Keep Spawn Loaded range per world
-
-This lets you disable it for some worlds and lower it for others.
-
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
- 
-     // CraftBukkit start
-     public void prepareLevels(ChunkProgressListener worldloadlistener, ServerLevel worldserver) {
-+        ServerChunkCache chunkproviderserver = worldserver.getChunkSource(); // Paper - Configurable Keep Spawn Loaded range per world
-         // WorldServer worldserver = this.overworld();
-         this.forceTicks = true;
-         // CraftBukkit end
-+        if (worldserver.getWorld().getKeepSpawnInMemory()) { // Paper - Configurable Keep Spawn Loaded range per world
- 
-         MinecraftServer.LOGGER.info("Preparing start region for dimension {}", worldserver.dimension().location());
-         BlockPos blockposition = worldserver.getSharedSpawnPos();
- 
-         worldloadlistener.updateSpawnPos(new ChunkPos(blockposition));
--        ServerChunkCache chunkproviderserver = worldserver.getChunkSource();
-+        //ChunkProviderServer chunkproviderserver = worldserver.getChunkProvider(); // Paper - Configurable Keep Spawn Loaded range per world; move up
- 
-         this.nextTickTimeNanos = Util.getNanos();
--        // CraftBukkit start
--        if (worldserver.getWorld().getKeepSpawnInMemory()) {
--            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(blockposition), 11, Unit.INSTANCE);
-+        // Paper start - Configurable Keep Spawn Loaded range per world
-+        int radiusBlocks = worldserver.paperConfig().spawn.keepSpawnLoadedRange * 16;
-+        int radiusChunks = radiusBlocks / 16 + ((radiusBlocks & 15) != 0 ? 1 : 0);
-+        int totalChunks = ((radiusChunks) * 2 + 1);
-+        totalChunks *= totalChunks;
-+        worldloadlistener.setChunkRadius(radiusBlocks / 16);
- 
--            while (chunkproviderserver.getTickingGenerated() != 441) {
--                // this.nextTickTimeNanos = SystemUtils.getNanos() + MinecraftServer.PREPARE_LEVELS_DEFAULT_DELAY_NANOS;
--                this.executeModerately();
--            }
--        }
-+        worldserver.addTicketsForSpawn(radiusBlocks, blockposition);
-+        // Paper end - Configurable Keep Spawn Loaded range per world
- 
-         // this.nextTickTimeNanos = SystemUtils.getNanos() + MinecraftServer.PREPARE_LEVELS_DEFAULT_DELAY_NANOS;
-         this.executeModerately();
-         // Iterator iterator = this.levels.values().iterator();
-+        } // Paper - Configurable Keep Spawn Loaded range per world
- 
-         if (true) {
-             ServerLevel worldserver1 = worldserver;
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         // this.nextTickTimeNanos = SystemUtils.getNanos() + MinecraftServer.PREPARE_LEVELS_DEFAULT_DELAY_NANOS;
-         this.executeModerately();
-         // CraftBukkit end
--        worldloadlistener.stop();
-+        if (worldserver.getWorld().getKeepSpawnInMemory()) worldloadlistener.stop(); // Paper - Configurable Keep Spawn Loaded range per world
-         // CraftBukkit start
-         // this.updateMobSpawningFlags();
-         worldserver.setSpawnSettings(this.isSpawningMonsters(), this.isSpawningAnimals());
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
-         return ((MapIndex) this.getServer().overworld().getDataStorage().computeIfAbsent(MapIndex.factory(), "idcounts")).getFreeAuxValueForMap();
-     }
- 
-+    // Paper start - Configurable Keep Spawn Loaded range per world
-+    public void addTicketsForSpawn(int radiusInBlocks, BlockPos spawn) {
-+        // In order to respect vanilla behavior, which is ensuring everything but the spawn border can tick, we add tickets
-+        // with level 31 for the non-border spawn chunks
-+        ServerChunkCache chunkproviderserver = this.getChunkSource();
-+        int tickRadius = radiusInBlocks - 16;
-+
-+        // add ticking chunks
-+        for (int x = -tickRadius; x <= tickRadius; x += 16) {
-+            for (int z = -tickRadius; z <= tickRadius; z += 16) {
-+                // radius of 2 will have the current chunk be level 31
-+                chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, z)), 2, Unit.INSTANCE);
-+            }
-+        }
-+
-+        // add border chunks
-+
-+        // add border along x axis (including corner chunks)
-+        for (int x = -radiusInBlocks; x <= radiusInBlocks; x += 16) {
-+            // top
-+            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, radiusInBlocks)), 1, Unit.INSTANCE); // level 32
-+            // bottom
-+            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, -radiusInBlocks)), 1, Unit.INSTANCE); // level 32
-+        }
-+
-+        // add border along z axis (excluding corner chunks)
-+        for (int z = -radiusInBlocks + 16; z < radiusInBlocks; z += 16) {
-+            // right
-+            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.offset(radiusInBlocks, 0, z)), 1, Unit.INSTANCE); // level 32
-+            // left
-+            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.offset(-radiusInBlocks, 0, z)), 1, Unit.INSTANCE); // level 32
-+        }
-+    }
-+    public void removeTicketsForSpawn(int radiusInBlocks, BlockPos spawn) {
-+        // In order to respect vanilla behavior, which is ensuring everything but the spawn border can tick, we added tickets
-+        // with level 31 for the non-border spawn chunks
-+        ServerChunkCache chunkproviderserver = this.getChunkSource();
-+        int tickRadius = radiusInBlocks - 16;
-+
-+        // remove ticking chunks
-+        for (int x = -tickRadius; x <= tickRadius; x += 16) {
-+            for (int z = -tickRadius; z <= tickRadius; z += 16) {
-+                // radius of 2 will have the current chunk be level 31
-+                chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, z)), 2, Unit.INSTANCE);
-+            }
-+        }
-+
-+        // remove border chunks
-+
-+        // remove border along x axis (including corner chunks)
-+        for (int x = -radiusInBlocks; x <= radiusInBlocks; x += 16) {
-+            // top
-+            chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, radiusInBlocks)), 1, Unit.INSTANCE); // level 32
-+            // bottom
-+            chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, -radiusInBlocks)), 1, Unit.INSTANCE); // level 32
-+        }
-+
-+        // remove border along z axis (excluding corner chunks)
-+        for (int z = -radiusInBlocks + 16; z < radiusInBlocks; z += 16) {
-+            // right
-+            chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.offset(radiusInBlocks, 0, z)), 1, Unit.INSTANCE); // level 32
-+            // left
-+            chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.offset(-radiusInBlocks, 0, z)), 1, Unit.INSTANCE); // level 32
-+        }
-+    }
-+    // Paper end - Configurable Keep Spawn Loaded range per world
-+
-     public void setDefaultSpawnPos(BlockPos pos, float angle) {
--        ChunkPos chunkcoordintpair = new ChunkPos(new BlockPos(this.levelData.getXSpawn(), 0, this.levelData.getZSpawn()));
-+        // Paper start - Configurable Keep Spawn Loaded range per world
-+        BlockPos prevSpawn = this.getSharedSpawnPos();
-+        //ChunkCoordIntPair chunkcoordintpair = new ChunkCoordIntPair(new BlockPosition(this.worldData.a(), 0, this.worldData.c()));
- 
-         this.levelData.setSpawn(pos, angle);
--        this.getChunkSource().removeRegionTicket(TicketType.START, chunkcoordintpair, 11, Unit.INSTANCE);
--        this.getChunkSource().addRegionTicket(TicketType.START, new ChunkPos(pos), 11, Unit.INSTANCE);
-+        if (this.keepSpawnInMemory) {
-+            // if this keepSpawnInMemory is false a plugin has already removed our tickets, do not re-add
-+            this.removeTicketsForSpawn(this.paperConfig().spawn.keepSpawnLoadedRange * 16, prevSpawn);
-+            this.addTicketsForSpawn(this.paperConfig().spawn.keepSpawnLoadedRange * 16, pos);
-+        }
-         this.getServer().getPlayerList().broadcastAll(new ClientboundSetDefaultSpawnPositionPacket(pos, angle));
-     }
- 
-diff --git a/src/main/java/net/minecraft/server/level/progress/ChunkProgressListener.java b/src/main/java/net/minecraft/server/level/progress/ChunkProgressListener.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/progress/ChunkProgressListener.java
-+++ b/src/main/java/net/minecraft/server/level/progress/ChunkProgressListener.java
-@@ -0,0 +0,0 @@ public interface ChunkProgressListener {
-     void start();
- 
-     void stop();
-+
-+    void setChunkRadius(int radius); // Paper - Configurable Keep Spawn Loaded range per world
- }
-diff --git a/src/main/java/net/minecraft/server/level/progress/LoggerChunkProgressListener.java b/src/main/java/net/minecraft/server/level/progress/LoggerChunkProgressListener.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/progress/LoggerChunkProgressListener.java
-+++ b/src/main/java/net/minecraft/server/level/progress/LoggerChunkProgressListener.java
-@@ -0,0 +0,0 @@ import org.slf4j.Logger;
- 
- public class LoggerChunkProgressListener implements ChunkProgressListener {
-     private static final Logger LOGGER = LogUtils.getLogger();
--    private final int maxCount;
-+    private int maxCount; // Paper - remove final
-     private int count;
-     private long startTime;
-     private long nextTickTime = Long.MAX_VALUE;
- 
-     public LoggerChunkProgressListener(int radius) {
-+        // Paper start - Configurable Keep Spawn Loaded range per world
-+        this.setChunkRadius(radius); // Move to method
-+    }
-+
-+    @Override
-+    public void setChunkRadius(int radius) {
-+        // Paper end - Configurable Keep Spawn Loaded range per world
-         int i = radius * 2 + 1;
-         this.maxCount = i * i;
-     }
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World {
- 
-     @Override
-     public void setKeepSpawnInMemory(boolean keepLoaded) {
-+        // Paper start - Configurable spawn radius
-+        if (keepLoaded == this.world.keepSpawnInMemory) {
-+            // do nothing, nothing has changed
-+            return;
-+        }
-         this.world.keepSpawnInMemory = keepLoaded;
-         // Grab the worlds spawn chunk
-         BlockPos chunkcoordinates = this.world.getSharedSpawnPos();
-         if (keepLoaded) {
--            this.world.getChunkSource().addRegionTicket(TicketType.START, new ChunkPos(chunkcoordinates), 11, Unit.INSTANCE);
-+            this.world.addTicketsForSpawn(this.world.paperConfig().spawn.keepSpawnLoadedRange * 16, chunkcoordinates);
-         } else {
--            // TODO: doesn't work well if spawn changed....
--            this.world.getChunkSource().removeRegionTicket(TicketType.START, new ChunkPos(chunkcoordinates), 11, Unit.INSTANCE);
-+            // TODO: doesn't work well if spawn changed.... // Paper - resolved
-+            this.world.removeTicketsForSpawn(this.world.paperConfig().spawn.keepSpawnLoadedRange * 16, chunkcoordinates);
-         }
-+        // Paper end
-     }
- 
-     @Override

patches/unapplied/server/Handle-Large-Packets-disconnecting-client.patch

@@ -1,134 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Tue, 27 Nov 2018 21:18:06 -0500
-Subject: [PATCH] Handle Large Packets disconnecting client
-
-If a players inventory is too big to send in a single packet,
-split the inventory set into multiple packets instead.
-
-diff --git a/src/main/java/net/minecraft/network/Connection.java b/src/main/java/net/minecraft/network/Connection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/Connection.java
-+++ b/src/main/java/net/minecraft/network/Connection.java
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
-     }
- 
-     public void exceptionCaught(ChannelHandlerContext channelhandlercontext, Throwable throwable) {
-+        // Paper start - Handle large packets disconnecting client
-+        if (throwable instanceof io.netty.handler.codec.EncoderException && throwable.getCause() instanceof PacketEncoder.PacketTooLargeException packetTooLargeException) {
-+            final Packet<?> packet = packetTooLargeException.getPacket();
-+            final io.netty.util.Attribute<ConnectionProtocol.CodecData<?>> codecDataAttribute = channelhandlercontext.channel().attr(packetTooLargeException.codecKey);
-+            if (packet.packetTooLarge(this)) {
-+                ProtocolSwapHandler.swapProtocolIfNeeded(codecDataAttribute, packet);
-+                return;
-+            } else if (packet.isSkippable()) {
-+                Connection.LOGGER.debug("Skipping packet due to errors", throwable.getCause());
-+                ProtocolSwapHandler.swapProtocolIfNeeded(codecDataAttribute, packet);
-+                return;
-+            } else {
-+                throwable = throwable.getCause();
-+            }
-+        }
-+        // Paper end - Handle large packets disconnecting client
-         if (throwable instanceof SkipPacketException) {
-             Connection.LOGGER.debug("Skipping packet due to errors", throwable.getCause());
-         } else {
-diff --git a/src/main/java/net/minecraft/network/PacketEncoder.java b/src/main/java/net/minecraft/network/PacketEncoder.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/PacketEncoder.java
-+++ b/src/main/java/net/minecraft/network/PacketEncoder.java
-@@ -0,0 +0,0 @@ public class PacketEncoder extends MessageToByteEncoder<Packet<?>> {
-                     int j = friendlyByteBuf.writerIndex();
-                     packet.write(friendlyByteBuf);
-                     int k = friendlyByteBuf.writerIndex() - j;
--                    if (k > 8388608) {
-+                    if (false && k > 8388608) { // Paper - Handle large packets disconnecting client; disable
-                         throw new IllegalArgumentException("Packet too big (is " + k + ", should be less than 8388608): " + packet);
-                     }
- 
-@@ -0,0 +0,0 @@ public class PacketEncoder extends MessageToByteEncoder<Packet<?>> {
- 
-                     throw var13;
-                 } finally {
-+                    // Paper start - Handle large packets disconnecting client
-+                    int packetLength = friendlyByteBuf.readableBytes();
-+                    if (packetLength > MAX_PACKET_SIZE) {
-+                        throw new PacketTooLargeException(packet, this.codecKey, packetLength);
-+                    }
-+                    // Paper end - Handle large packets disconnecting client
-                     ProtocolSwapHandler.swapProtocolIfNeeded(attribute, packet);
-                 }
-             }
-         }
-     }
-+
-+    // Paper start
-+    private static int MAX_PACKET_SIZE = 8388608;
-+
-+    public static class PacketTooLargeException extends RuntimeException {
-+        private final Packet<?> packet;
-+        public final AttributeKey<ConnectionProtocol.CodecData<?>> codecKey;
-+
-+        PacketTooLargeException(Packet<?> packet, AttributeKey<ConnectionProtocol.CodecData<?>> codecKey, int packetLength) {
-+            super("PacketTooLarge - " + packet.getClass().getSimpleName() + " is " + packetLength + ". Max is " + MAX_PACKET_SIZE);
-+            this.packet = packet;
-+            this.codecKey = codecKey;
-+        }
-+
-+        public Packet<?> getPacket() {
-+            return this.packet;
-+        }
-+    }
-+    // Paper end
- }
-diff --git a/src/main/java/net/minecraft/network/protocol/Packet.java b/src/main/java/net/minecraft/network/protocol/Packet.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/protocol/Packet.java
-+++ b/src/main/java/net/minecraft/network/protocol/Packet.java
-@@ -0,0 +0,0 @@ public interface Packet<T extends PacketListener> {
- 
-     void handle(T listener);
- 
-+    // Paper start
-+    default boolean packetTooLarge(net.minecraft.network.Connection manager) {
-+        return false;
-+    }
-+    // Paper end
-+
-     default boolean isSkippable() {
-         return false;
-     }
-diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundContainerSetContentPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundContainerSetContentPacket.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/protocol/game/ClientboundContainerSetContentPacket.java
-+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundContainerSetContentPacket.java
-@@ -0,0 +0,0 @@ public class ClientboundContainerSetContentPacket implements Packet<ClientGamePa
-         this.carriedItem = buf.readItem();
-     }
- 
-+    // Paper start
-+    @Override
-+    public boolean packetTooLarge(net.minecraft.network.Connection manager) {
-+        for (int i = 0 ; i < this.items.size() ; i++) {
-+            manager.send(new ClientboundContainerSetSlotPacket(this.containerId, this.stateId, i, this.items.get(i)));
-+        }
-+        return true;
-+    }
-+    // Paper end
-+
-     @Override
-     public void write(FriendlyByteBuf buf) {
-         buf.writeByte(this.containerId);
-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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
-+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
-@@ -0,0 +0,0 @@ public class ClientboundLevelChunkPacketData {
-             throw new RuntimeException("Can't read heightmap in packet for [" + x + ", " + z + "]");
-         } else {
-             int i = buf.readVarInt();
--            if (i > 2097152) {
-+            if (i > 2097152) { // Paper - diff on change - if this changes, update PacketEncoder
-                 throw new RuntimeException("Chunk Packet trying to allocate too much memory on read.");
-             } else {
-                 this.buffer = new byte[i];