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())) {
+                                 if (!this.player.isChangingDimension() && (!this.player.level().getGameRules().getBoolean(GameRules.RULE_DISABLE_ELYTRA_MOVEMENT_CHECK) || !flag)) {
-                                     float f2 = this.player.isFallFlying() ? 300.0F : 100.0F;
+                                     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.setCustomName(Component.Serializer.fromJson(nbt.getString("CustomName"), registries));
-+            this.setName(io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt)); // Paper - Catch ParseException
++            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) {
+     protected void loadAdditional(CompoundTag nbt, HolderLookup.Provider registryLookup) {
-         super.load(nbt);
+         super.loadAdditional(nbt, registryLookup);
          if (nbt.contains("CustomName", 8)) {
--            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"));
+-            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"), registryLookup);
-+            this.name = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt); // Paper - Catch ParseException
++            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 = Component.Serializer.fromJson(nbt.getString("CustomName"), registryLookup);
-+            this.name = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt); // Paper - Catch ParseException
++            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 = Component.Serializer.fromJson(nbt.getString("CustomName"), registryLookup);
-+            this.name = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt); // Paper - Catch ParseException
++            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
+--- a/src/main/java/net/minecraft/world/level/block/entity/EnchantingTableBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/EnchantmentTableBlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/EnchantingTableBlockEntity.java
-@@ -0,0 +0,0 @@ public class EnchantmentTableBlockEntity extends BlockEntity implements Nameable
+@@ -0,0 +0,0 @@ public class EnchantingTableBlockEntity extends BlockEntity implements Nameable
-     public void load(CompoundTag nbt) {
+     protected void loadAdditional(CompoundTag nbt, HolderLookup.Provider registryLookup) {
-         super.load(nbt);
+         super.loadAdditional(nbt, registryLookup);
          if (nbt.contains("CustomName", 8)) {
--            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"));
+-            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"), registryLookup);
-+            this.name = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt); // Paper - Catch ParseException
++            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) {
+             synchronized (ServerHandshakePacketListenerImpl.throttleTracker) {
-                         if (ServerHandshakePacketListenerImpl.throttleTracker.containsKey(address) && !"127.0.0.1".equals(address.getHostAddress()) && currentTime - ServerHandshakePacketListenerImpl.throttleTracker.get(address) < connectionThrottle) {
+                 if (ServerHandshakePacketListenerImpl.throttleTracker.containsKey(address) && !"127.0.0.1".equals(address.getHostAddress()) && currentTime - ServerHandshakePacketListenerImpl.throttleTracker.get(address) < connectionThrottle) {
-                             ServerHandshakePacketListenerImpl.throttleTracker.put(address, currentTime);
+                     ServerHandshakePacketListenerImpl.throttleTracker.put(address, currentTime);
--                            MutableComponent chatmessage = Component.literal("Connection throttled! Please wait before reconnecting.");
+-                    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.send(new ClientboundLoginDisconnectPacket(chatmessage));
-                             this.connection.disconnect(chatmessage);
+                     this.connection.disconnect(chatmessage);
-                             return;
+                     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
+             CompoundTag nbttagcompound = ((CompoundTag) optional.get()).getCompound("RootVehicle");
-             ServerLevel finalWorldServer = worldserver1;
+             ServerLevel finalWorldServer = worldserver1; // CraftBukkit - decompile error
-             Entity entity = EntityType.loadEntityRecursive(nbttagcompound1.getCompound("Entity"), finalWorldServer, (entity1) -> {
+             Entity entity = EntityType.loadEntityRecursive(nbttagcompound.getCompound("Entity"), worldserver1, (entity1) -> {
--                return !finalWorldServer.addWithUUID(entity1) ? null : entity1;
+-                return !finalWorldServer.addWithUUID(entity1) ? null : entity1; // CraftBukkit - decompile error
-+                return !finalWorldServer.addWithUUID(entity1, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.MOUNT) ? null : entity1; // Paper - Entity#getEntitySpawnReason
++                return !finalWorldServer.addWithUUID(entity1, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.MOUNT) ? null : entity1; // CraftBukkit - decompile error // Paper - Entity#getEntitySpawnReason
-                 // CraftBukkit end
              });
  
+             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();
+-                ItemStack itemStack2 = StackedContents.fromStackingIndex(m);
-+                int n = StackedContents.maxStackSizeFromStackingIndex(m, this.stackedContents); // Paper - Improve exact choice recipe ingredients
++                ItemStack itemStack2 = StackedContents.fromStackingIndexWithExtras(m, this.stackedContents); // Paper - Improve exact choice recipe ingredients
-                 if (n < l) {
+                 if (!itemStack2.isEmpty()) {
-                     l = n;
+                     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 (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.hasCustomHoverName()) {
+         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() {
+                 new HashMap<>(nms.slotDropChances().entrySet().stream().collect(Collectors.toMap((entry) -> CraftEquipmentSlot.getSlot(entry.getKey()), Map.Entry::getValue)))
-         return new CraftCreatureSpawner(this);
+         )).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
+--- a/src/main/java/net/minecraft/world/item/component/LodestoneTracker.java
-+++ b/src/main/java/net/minecraft/world/item/CompassItem.java
++++ b/src/main/java/net/minecraft/world/item/component/LodestoneTracker.java
-@@ -0,0 +0,0 @@ public class CompassItem extends Item implements Vanishable {
+@@ -0,0 +0,0 @@ public record LodestoneTracker(Optional<GlobalPos> target, boolean tracked) {
-                 Optional<ResourceKey<Level>> optional = getLodestoneDimension(compoundTag);
+                 return this;
-                 if (optional.isPresent() && optional.get() == world.dimension() && compoundTag.contains("LodestonePos")) {
+             } else {
-                     BlockPos blockPos = NbtUtils.readBlockPos(compoundTag.getCompound("LodestonePos"));
+                 BlockPos blockPos = this.target.get().pos();
--                    if (!world.isInWorldBounds(blockPos) || !((ServerLevel)world).getPoiManager().existsAtPosition(PoiTypes.LODESTONE, blockPos)) {
+-                return world.isInWorldBounds(blockPos) && 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
++                return world.isInWorldBounds(blockPos) && (!world.hasChunkAt(blockPos) || world.getPoiManager().existsAtPosition(PoiTypes.LODESTONE, blockPos)) // Paper - Prevent compass from loading chunks
-                         compoundTag.remove("LodestonePos");
+                     ? 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
                  }
              }