More more more more more more more more more more more more more work

build-data/dev-imports.txt

@@ -8,3 +8,4 @@
 # To import classes from the vanilla Minecraft jar use `minecraft` as the artifactId:
 #     minecraft net.minecraft.world.level.entity.LevelEntityGetterAdapter
 #     minecraft net/minecraft/world/level/entity/LevelEntityGetter.java
+

patches/server/Add-entity-liquid-API.patch

@@ -8,7 +8,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, n
+@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, i
          return this.isInWater() || this.isInRain();
      }
  

patches/server/Improve-EntityTargetLivingEntityEvent-for-1.16-mobs.patch

@@ -16,7 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (!entity.canAttack(entityliving)) {
 -            this.clearAttackTarget(entity);
 +            this.clearAttackTarget(entity, org.bukkit.event.entity.EntityTargetEvent.TargetReason.TARGET_INVALID); // Paper
-         } else if (StopAttackingIfTargetInvalid.isTiredOfTryingToReachTarget((LivingEntity) entity)) {
+         } else if (StopAttackingIfTargetInvalid.isTiredOfTryingToReachTarget(entity)) {
 -            this.clearAttackTarget(entity);
 +            this.clearAttackTarget(entity, org.bukkit.event.entity.EntityTargetEvent.TargetReason.FORGOT_TARGET); // Paper
          } else if (this.isCurrentTargetDeadOrRemoved(entity)) {

patches/server/Optimize-Bit-Operations-by-inlining.patch

@@ -76,8 +76,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public static long asLong(int x, int y, int z) {
 -        long l = 0L;
--        l = l | ((long)x & PACKED_X_MASK) << X_OFFSET;
--        l = l | ((long)y & PACKED_Y_MASK) << 0;
+-        l |= ((long)x & PACKED_X_MASK) << X_OFFSET;
+-        l |= ((long)y & PACKED_Y_MASK) << 0;
 -        return l | ((long)z & PACKED_Z_MASK) << Z_OFFSET;
 +        return (((long) x & (long) 67108863) << 38) | (((long) y & (long) 4095)) | (((long) z & (long) 67108863) << 12); // Paper - inline constants and simplify
      }
@@ -180,8 +180,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
      public static long asLong(int x, int y, int z) {
 -        long l = 0L;
--        l = l | ((long)x & 4194303L) << 42;
--        l = l | ((long)y & 1048575L) << 0;
+-        l |= ((long)x & 4194303L) << 42;
+-        l |= ((long)y & 1048575L) << 0;
 -        return l | ((long)z & 4194303L) << 20;
 +        return (((long) x & 4194303L) << 42) | (((long) y & 1048575L)) | (((long) z & 4194303L) << 20); // Paper - Simplify to reduce instruction count
      }

patches/server/Optimize-NibbleArray-to-use-pooled-buffers.patch

@@ -8,26 +8,91 @@ an object pool for these.
 
 Uses lots of advanced new capabilities of the Paper codebase :)
 
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java
++++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java
+@@ -0,0 +0,0 @@ package net.minecraft.network.protocol.game;
+ 
+ import java.util.BitSet;
+ import javax.annotation.Nullable;
++
++import io.netty.channel.ChannelFuture;
+ import net.minecraft.network.FriendlyByteBuf;
+ import net.minecraft.network.protocol.Packet;
++import net.minecraft.server.level.ServerPlayer;
+ import net.minecraft.world.level.ChunkPos;
+ import net.minecraft.world.level.chunk.LevelChunk;
+ import net.minecraft.world.level.lighting.LevelLightEngine;
+@@ -0,0 +0,0 @@ public class ClientboundLevelChunkWithLightPacket implements Packet<ClientGamePa
+     private final ClientboundLevelChunkPacketData chunkData;
+     private final ClientboundLightUpdatePacketData lightData;
+ 
++    // Paper start
++    @Override
++    public void onPacketDispatch(ServerPlayer player) {
++        lightData.onPacketDispatch(player);
++    }
++
++    @Override
++    public void onPacketDispatchFinish(ServerPlayer player, ChannelFuture future) {
++        lightData.onPacketDispatchFinish(player, future);
++    }
++
++    @Override
++    public boolean hasFinishListener() {
++        return true;
++    }
++    // Paper end
++
+     public ClientboundLevelChunkWithLightPacket(LevelChunk chunk, LevelLightEngine lightProvider, @Nullable BitSet bitSet, @Nullable BitSet bitSet2, boolean bl) {
+         ChunkPos chunkPos = chunk.getPos();
+         this.x = chunkPos.x;
 diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundLightUpdatePacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundLightUpdatePacket.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/network/protocol/game/ClientboundLightUpdatePacket.java
 +++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundLightUpdatePacket.java
 @@ -0,0 +0,0 @@ package net.minecraft.network.protocol.game;
  
- import com.google.common.collect.Lists;
  import java.util.BitSet;
-+import io.netty.channel.ChannelFuture; // Paper
- import java.util.List;
  import javax.annotation.Nullable;
- import net.minecraft.core.SectionPos;
++
++import io.netty.channel.ChannelFuture;
  import net.minecraft.network.FriendlyByteBuf;
  import net.minecraft.network.protocol.Packet;
-+import net.minecraft.server.MCUtil;
 +import net.minecraft.server.level.ServerPlayer;
  import net.minecraft.world.level.ChunkPos;
- import net.minecraft.world.level.LightLayer;
- import net.minecraft.world.level.chunk.DataLayer;
+ import net.minecraft.world.level.lighting.LevelLightEngine;
+ 
 @@ -0,0 +0,0 @@ public class ClientboundLightUpdatePacket implements Packet<ClientGamePacketList
+     private final int z;
+     private final ClientboundLightUpdatePacketData lightData;
+ 
++    // Paper start
++    @Override
++    public void onPacketDispatch(ServerPlayer player) {
++        lightData.onPacketDispatch(player);
++    }
++
++    @Override
++    public void onPacketDispatchFinish(ServerPlayer player, ChannelFuture future) {
++        lightData.onPacketDispatchFinish(player, future);
++    }
++
++    @Override
++    public boolean hasFinishListener() {
++        return true;
++    }
++    // Paper end
++
+     public ClientboundLightUpdatePacket(ChunkPos chunkPos, LevelLightEngine lightProvider, @Nullable BitSet skyBits, @Nullable BitSet blockBits, boolean nonEdge) {
+         this.x = chunkPos.x;
+         this.z = chunkPos.z;
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundLightUpdatePacketData.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundLightUpdatePacketData.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundLightUpdatePacketData.java
++++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundLightUpdatePacketData.java
+@@ -0,0 +0,0 @@ public class ClientboundLightUpdatePacketData {
      private final List<byte[]> skyUpdates;
      private final List<byte[]> blockUpdates;
      private final boolean trustEdges;
@@ -36,16 +101,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    java.lang.Runnable cleaner2;
 +    java.util.concurrent.atomic.AtomicInteger remainingSends = new java.util.concurrent.atomic.AtomicInteger(0);
 +
-+    @Override
-+    public void onPacketDispatch(ServerPlayer player) {
++    public void onPacketDispatch(net.minecraft.server.level.ServerPlayer player) {
 +        remainingSends.incrementAndGet();
 +    }
 +
-+    @Override
-+    public void onPacketDispatchFinish(ServerPlayer player, ChannelFuture future) {
++    public void onPacketDispatchFinish(net.minecraft.server.level.ServerPlayer player, io.netty.channel.ChannelFuture future) {
 +        if (remainingSends.decrementAndGet() <= 0) {
 +            // incase of any race conditions, schedule this delayed
-+            MCUtil.scheduleTask(5, () -> {
++            net.minecraft.server.MCUtil.scheduleTask(5, () -> {
 +                if (remainingSends.get() == 0) {
 +                    cleaner1.run();
 +                    cleaner2.run();
@@ -53,33 +116,27 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            }, "Light Packet Release");
 +        }
 +    }
-+
-+    @Override
-+    public boolean hasFinishListener() {
-+        return true;
-+    }
-+
 +    // Paper end
  
-     public ClientboundLightUpdatePacket(ChunkPos chunkPos, LevelLightEngine lightProvider, @Nullable BitSet bitSet, @Nullable BitSet bitSet2, boolean nonEdge) {
-         this.x = chunkPos.x;
-@@ -0,0 +0,0 @@ public class ClientboundLightUpdatePacket implements Packet<ClientGamePacketList
+     public ClientboundLightUpdatePacketData(ChunkPos pos, LevelLightEngine lightProvider, @Nullable BitSet skyBits, @Nullable BitSet blockBits, boolean nonEdge) {
+         this.trustEdges = nonEdge;
+@@ -0,0 +0,0 @@ public class ClientboundLightUpdatePacketData {
          this.blockYMask = new BitSet();
          this.emptySkyYMask = new BitSet();
          this.emptyBlockYMask = new BitSet();
 -        this.skyUpdates = Lists.newArrayList();
 -        this.blockUpdates = Lists.newArrayList();
-+        this.skyUpdates = Lists.newArrayList();this.cleaner1 = MCUtil.registerListCleaner(this, this.skyUpdates, DataLayer::releaseBytes); // Paper
-+        this.blockUpdates = Lists.newArrayList();this.cleaner2 = MCUtil.registerListCleaner(this, this.blockUpdates, DataLayer::releaseBytes); // Paper
++        this.skyUpdates = Lists.newArrayList();this.cleaner1 = net.minecraft.server.MCUtil.registerListCleaner(this, this.skyUpdates, DataLayer::releaseBytes); // Paper
++        this.blockUpdates = Lists.newArrayList();this.cleaner2 = net.minecraft.server.MCUtil.registerListCleaner(this, this.blockUpdates, DataLayer::releaseBytes); // Paper
  
          for(int i = 0; i < lightProvider.getLightSectionCount(); ++i) {
-             if (bitSet == null || bitSet.get(i)) {
-@@ -0,0 +0,0 @@ public class ClientboundLightUpdatePacket implements Packet<ClientGamePacketList
-                 bitSet2.set(i);
+             if (skyBits == null || skyBits.get(i)) {
+@@ -0,0 +0,0 @@ public class ClientboundLightUpdatePacketData {
+                 uninitialized.set(y);
              } else {
-                 bitSet.set(i);
--                list.add((byte[])dataLayer.getData().clone());
-+                list.add((byte[])dataLayer.getCloneIfSet()); // Paper
+                 initialized.set(y);
+-                nibbles.add((byte[])dataLayer.getData().clone());
++                nibbles.add((byte[])dataLayer.getCloneIfSet()); // Paper
              }
          }
  
@@ -151,7 +208,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        registerCleaner();
 +        // Paper end
          if (bytes.length != 2048) {
-             throw (IllegalArgumentException) Util.pauseInIde((Throwable) (new IllegalArgumentException("DataLayer should be 2048 bytes not: " + bytes.length)));
+             throw (IllegalArgumentException) Util.pauseInIde(new IllegalArgumentException("DataLayer should be 2048 bytes not: " + bytes.length));
          }
 @@ -0,0 +0,0 @@ public final class DataLayer {
  
@@ -206,16 +263,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  }
  
                  if (nibblearray != null && !nibblearray.isEmpty()) {
--                    nbttagcompound2.putByteArray("BlockLight", nibblearray.getData());
-+                    nbttagcompound2.putByteArray("BlockLight", nibblearray.asBytesPoolSafe().clone()); // Paper
+-                    nbttagcompound1.putByteArray("BlockLight", nibblearray.getData());
++                    nbttagcompound1.putByteArray("BlockLight", nibblearray.asBytesPoolSafe().clone()); // Paper
                  }
  
                  if (nibblearray1 != null && !nibblearray1.isEmpty()) {
--                    nbttagcompound2.putByteArray("SkyLight", nibblearray1.getData());
-+                    nbttagcompound2.putByteArray("SkyLight", nibblearray1.asBytesPoolSafe().clone()); // Paper
+-                    nbttagcompound1.putByteArray("SkyLight", nibblearray1.getData());
++                    nbttagcompound1.putByteArray("SkyLight", nibblearray1.asBytesPoolSafe().clone()); // Paper
                  }
  
-                 nbttaglist.add(nbttagcompound2);
+                 if (!nbttagcompound1.isEmpty()) {
 diff --git a/src/main/java/net/minecraft/world/level/lighting/DataLayerStorageMap.java b/src/main/java/net/minecraft/world/level/lighting/DataLayerStorageMap.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/lighting/DataLayerStorageMap.java
@@ -246,11 +303,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      protected void clearQueuedSectionBlocks(LayerLightEngine<?, ?> storage, long sectionPos) {
 @@ -0,0 +0,0 @@ public abstract class LayerLightSectionStorage<M extends DataLayerStorageMap<M>>
  
-     protected void queueSectionData(long sectionPos, @Nullable DataLayer array, boolean bl) {
+     protected void queueSectionData(long sectionPos, @Nullable DataLayer array, boolean nonEdge) {
          if (array != null) {
 -            this.queuedSections.put(sectionPos, array);
 +            DataLayer remove = this.queuedSections.put(sectionPos, array); if (remove != null && remove.cleaner != null) remove.cleaner.run(); // Paper - clean up when removed
-             if (!bl) {
+             if (!nonEdge) {
                  this.untrustedSections.add(sectionPos);
              }
          } else {
@@ -303,19 +360,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
 @@ -0,0 +0,0 @@ public class CraftChunk implements Chunk {
-                     sectionSkyLights[i] = CraftChunk.emptyLight;
-                 } else {
-                     sectionSkyLights[i] = new byte[2048];
--                    System.arraycopy(skyLightArray.getData(), 0, sectionSkyLights[i], 0, 2048);
-+                    System.arraycopy(skyLightArray.getIfSet(), 0, sectionSkyLights[i], 0, 2048); // Paper
-                 }
-                 DataLayer emitLightArray = lightengine.getLayerListener(LightLayer.BLOCK).getDataLayerData(SectionPos.of(x, i, z));
-                 if (emitLightArray == null) {
-                     sectionEmitLights[i] = CraftChunk.emptyLight;
-                 } else {
-                     sectionEmitLights[i] = new byte[2048];
--                    System.arraycopy(emitLightArray.getData(), 0, sectionEmitLights[i], 0, 2048);
-+                    System.arraycopy(emitLightArray.getIfSet(), 0, sectionEmitLights[i], 0, 2048); // Paper
-                 }
+                 sectionSkyLights[i] = CraftChunk.emptyLight;
+             } else {
+                 sectionSkyLights[i] = new byte[2048];
+-                System.arraycopy(skyLightArray.getData(), 0, sectionSkyLights[i], 0, 2048);
++                System.arraycopy(skyLightArray.getIfSet(), 0, sectionSkyLights[i], 0, 2048); // Paper
              }
-         }
+             DataLayer emitLightArray = lightengine.getLayerListener(LightLayer.BLOCK).getDataLayerData(SectionPos.of(x, i, z));
+             if (emitLightArray == null) {
+                 sectionEmitLights[i] = CraftChunk.emptyLight;
+             } else {
+                 sectionEmitLights[i] = new byte[2048];
+-                System.arraycopy(emitLightArray.getData(), 0, sectionEmitLights[i], 0, 2048);
++                System.arraycopy(emitLightArray.getIfSet(), 0, sectionEmitLights[i], 0, 2048); // Paper
+             }
+ 
+             if (biome != null) {

patches/server/Remove-some-streams-from-structures.patch

@@ -0,0 +1,37 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Josh Roy <10731363+JRoy@users.noreply.github.com>
+Date: Mon, 29 Jun 2020 17:03:06 -0400
+Subject: [PATCH] Remove some streams from structures
+
+This showed up a lot in the spark profiler, should have a low-medium performance improvement.
+
+diff --git a/src/main/java/net/minecraft/world/level/levelgen/Beardifier.java b/src/main/java/net/minecraft/world/level/levelgen/Beardifier.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/Beardifier.java
++++ b/src/main/java/net/minecraft/world/level/levelgen/Beardifier.java
+@@ -0,0 +0,0 @@ import net.minecraft.world.level.levelgen.feature.structures.StructureTemplatePo
+ import net.minecraft.world.level.levelgen.structure.BoundingBox;
+ import net.minecraft.world.level.levelgen.structure.PoolElementStructurePiece;
+ import net.minecraft.world.level.levelgen.structure.StructurePiece;
++import net.minecraft.world.level.levelgen.structure.StructureStart;
+ 
+ public class Beardifier implements NoiseChunk.NoiseFiller {
+     public static final int BEARD_KERNEL_RADIUS = 12;
+@@ -0,0 +0,0 @@ public class Beardifier implements NoiseChunk.NoiseFiller {
+         this.rigids = new ObjectArrayList<>(10);
+ 
+         for(StructureFeature<?> structureFeature : StructureFeature.NOISE_AFFECTING_FEATURES) {
+-            structureAccessor.startsForFeature(SectionPos.bottomOf(chunk), structureFeature).forEach((structureStart) -> {
++            for (StructureStart<?> structureStart : structureAccessor.startsForFeature(SectionPos.bottomOf(chunk), structureFeature)) { // Paper - remove streams
+                 for(StructurePiece structurePiece : structureStart.getPieces()) {
+                     if (structurePiece.isCloseToChunk(chunkPos, 12)) {
+                         if (structurePiece instanceof PoolElementStructurePiece) {
+@@ -0,0 +0,0 @@ public class Beardifier implements NoiseChunk.NoiseFiller {
+                     }
+                 }
+ 
+-            });
++            } // Paper
+         }
+ 
+         this.pieceIterator = this.rigids.iterator();

patches/server/Stop-copy-on-write-operations-for-updating-light-dat.patch

@@ -180,20 +180,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
 @@ -0,0 +0,0 @@ public class SkyLightSectionStorage extends LayerLightSectionStorage<SkyLightSec
-     protected int getLightValue(long l, boolean bl) {
-         long m = SectionPos.blockToSection(l);
-         int i = SectionPos.y(m);
--        SkyLightSectionStorage.SkyDataLayerStorageMap skyDataLayerStorageMap = bl ? this.updatingSectionData : this.visibleSectionData;
--        int j = skyDataLayerStorageMap.topSections.get(SectionPos.getZeroNode(m));
+     protected int getLightValue(long blockPos, boolean cached) {
+         long l = SectionPos.blockToSection(blockPos);
+         int i = SectionPos.y(l);
+-        SkyLightSectionStorage.SkyDataLayerStorageMap skyDataLayerStorageMap = cached ? this.updatingSectionData : this.visibleSectionData;
+-        int j = skyDataLayerStorageMap.topSections.get(SectionPos.getZeroNode(l));
 +        synchronized (this.visibleUpdateLock) { // Paper - avoid copying light data
 +        SkyLightSectionStorage.SkyDataLayerStorageMap skyDataLayerStorageMap = (SkyLightSectionStorage.SkyDataLayerStorageMap) this.e_visible; // Paper - avoid copying light data - must be after lock acquire
-+        int j = skyDataLayerStorageMap.otherData.getVisibleAsync(SectionPos.getZeroNode(m)); // Paper - avoid copying light data
++        int j = skyDataLayerStorageMap.otherData.getVisibleAsync(SectionPos.getZeroNode(l)); // Paper - avoid copying light data
          if (j != skyDataLayerStorageMap.currentLowestY && i < j) {
-             DataLayer dataLayer = this.getDataLayer(skyDataLayerStorageMap, m);
+             DataLayer dataLayer = this.getDataLayer(skyDataLayerStorageMap, l);
              if (dataLayer == null) {
 @@ -0,0 +0,0 @@ public class SkyLightSectionStorage extends LayerLightSectionStorage<SkyLightSec
          } else {
-             return bl && !this.lightOnInSection(m) ? 0 : 15;
+             return cached && !this.lightOnInSection(l) ? 0 : 15;
          }
 +        } // Paper - avoid copying light data
      }

patches/server/Support-old-UUID-format-for-NBT.patch

@@ -53,48 +53,37 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  import org.apache.logging.log4j.Logger;
  
  public final class NbtUtils {
--    private static final Comparator<ListTag> YXZ_LISTTAG_INT_COMPARATOR = Comparator.comparingInt((listTag) -> {
-+    private static final Comparator<ListTag> YXZ_LISTTAG_INT_COMPARATOR = Comparator.<ListTag>comparingInt((listTag) -> { // Paper - decompile fix
-         return listTag.getInt(1);
-     }).thenComparingInt((listTag) -> {
-         return listTag.getInt(0);
-     }).thenComparingInt((listTag) -> {
-         return listTag.getInt(2);
+-    private static final Comparator<ListTag> YXZ_LISTTAG_INT_COMPARATOR = Comparator.comparingInt((nbt) -> {
++    private static final Comparator<ListTag> YXZ_LISTTAG_INT_COMPARATOR = Comparator.<ListTag>comparingInt((nbt) -> { // Paper - decompile fix
+         return nbt.getInt(1);
+     }).thenComparingInt((nbt) -> {
+         return nbt.getInt(0);
+     }).thenComparingInt((nbt) -> {
+         return nbt.getInt(2);
      });
--    private static final Comparator<ListTag> YXZ_LISTTAG_DOUBLE_COMPARATOR = Comparator.comparingDouble((listTag) -> {
-+    private static final Comparator<ListTag> YXZ_LISTTAG_DOUBLE_COMPARATOR = Comparator.<ListTag>comparingDouble((listTag) -> { // Paper - decompile fix
-         return listTag.getDouble(1);
-     }).thenComparingDouble((listTag) -> {
-         return listTag.getDouble(0);
+-    private static final Comparator<ListTag> YXZ_LISTTAG_DOUBLE_COMPARATOR = Comparator.comparingDouble((nbt) -> {
++    private static final Comparator<ListTag> YXZ_LISTTAG_DOUBLE_COMPARATOR = Comparator.<ListTag>comparingDouble((nbt) -> { // Paper - decompile fix
+         return nbt.getDouble(1);
+     }).thenComparingDouble((nbt) -> {
+         return nbt.getDouble(0);
 @@ -0,0 +0,0 @@ public final class NbtUtils {
+         if (compound.contains("Name", 8)) {
              string = compound.getString("Name");
          }
- 
 +        // Paper start - support string UUID's
 +        if (compound.contains("Id", 8)) {
 +            uUID = UUID.fromString(compound.getString("Id"));
 +        }
 +        // Paper end
+ 
          if (compound.hasUUID("Id")) {
              uUID = compound.getUUID("Id");
-         }
 @@ -0,0 +0,0 @@ public final class NbtUtils {
      }
  
      public static CompoundTag update(DataFixer fixer, DataFixTypes fixTypes, CompoundTag compound, int oldVersion, int targetVersion) {
 -        return fixer.update(fixTypes.getType(), new Dynamic<>(NbtOps.INSTANCE, compound), oldVersion, targetVersion).getValue();
-+        return (CompoundTag) fixer.update(fixTypes.getType(), new com.mojang.serialization.Dynamic<>(NbtOps.INSTANCE, compound), oldVersion, targetVersion).getValue(); // Paper - decompile fix
++        return (CompoundTag) fixer.update(fixTypes.getType(), new Dynamic<>(NbtOps.INSTANCE, compound), oldVersion, targetVersion).getValue(); // Paper - decompile fix
      }
  
      public static Component toPrettyComponent(Tag element) {
-@@ -0,0 +0,0 @@ public final class NbtUtils {
-             CompoundTag compoundTag2 = new CompoundTag();
-             if (i + 2 <= string.length()) {
-                 String string3 = string.substring(i + 1, string.indexOf(125, i));
--                COMMA_SPLITTER.split(string3).forEach((string2) -> {
--                    List<String> list = COLON_SPLITTER.splitToList(string2);
-+                COMMA_SPLITTER.split(string3).forEach(it -> { // Paper - decompile fix
-+                    List<String> list = COLON_SPLITTER.splitToList(it); // Paper - decompile fix
-                     if (list.size() == 2) {
-                         compoundTag2.putString(list.get(0), list.get(1));
-                     } else {

patches/server/Update-itemstack-legacy-name-and-lore.patch

@@ -54,7 +54,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public ItemStack(ItemLike item) {
 @@ -0,0 +0,0 @@ public final class ItemStack {
-             this.tag = (CompoundTag) nbttagcompound.getCompound("tag").copy();
+             this.tag = nbttagcompound.getCompound("tag").copy();
              // CraftBukkit end
              this.processEnchantOrder(this.tag); // Paper
 +            this.processText(); // Paper

patches/unapplied/api/Allow-delegation-to-vanilla-chunk-gen.patch

@@ -1,85 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MiniDigger | Martin <admin@minidigger.dev>
-Date: Wed, 29 Apr 2020 02:09:17 +0200
-Subject: [PATCH] Allow delegation to vanilla chunk gen
-
-
-diff --git a/src/main/java/org/bukkit/Bukkit.java b/src/main/java/org/bukkit/Bukkit.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/Bukkit.java
-+++ b/src/main/java/org/bukkit/Bukkit.java
-@@ -0,0 +0,0 @@ public final class Bukkit {
-         return server.createChunkData(world);
-     }
- 
-+    // Paper start
-+    /**
-+     * Create a ChunkData for use in a generator, that is populated by the vanilla generator for that world
-+     *
-+     * @param world the world to create the ChunkData for
-+     * @param x the x coordinate of the chunk
-+     * @param z the z coordinate of the chunk
-+     * @return a new ChunkData for the world
-+     *
-+     */
-+    @NotNull
-+    public static ChunkGenerator.ChunkData createVanillaChunkData(@NotNull World world, int x, int z) {
-+        return server.createVanillaChunkData(world, x, z);
-+    }
-+    // Paper stop
-+
-     /**
-      * Creates a boss bar instance to display to players. The progress
-      * defaults to 1.0
-diff --git a/src/main/java/org/bukkit/Server.java b/src/main/java/org/bukkit/Server.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/Server.java
-+++ b/src/main/java/org/bukkit/Server.java
-@@ -0,0 +0,0 @@ public interface Server extends PluginMessageRecipient, net.kyori.adventure.audi
-     @NotNull
-     public ChunkGenerator.ChunkData createChunkData(@NotNull World world);
- 
-+    // Paper start
-+    /**
-+     * Create a ChunkData for use in a generator, that is populated by the vanilla generator for that world
-+     *
-+     * @param world the world to create the ChunkData for
-+     * @param x the x coordinate of the chunk
-+     * @param z the z coordinate of the chunk
-+     * @return a new ChunkData for the world
-+     *
-+     */
-+    @NotNull
-+    ChunkGenerator.ChunkData createVanillaChunkData(@NotNull World world, int x, int z);
-+    // Paper end
-+
-     /**
-      * Creates a boss bar instance to display to players. The progress
-      * defaults to 1.0
-diff --git a/src/main/java/org/bukkit/generator/ChunkGenerator.java b/src/main/java/org/bukkit/generator/ChunkGenerator.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/generator/ChunkGenerator.java
-+++ b/src/main/java/org/bukkit/generator/ChunkGenerator.java
-@@ -0,0 +0,0 @@ public abstract class ChunkGenerator {
-         return false;
-     }
- 
-+    // Paper start
-+    /**
-+     * Create a ChunkData for use in a generator, that is populated by the vanilla generator for that world
-+     *
-+     * @param world the world to create the ChunkData for
-+     * @param x the x coordinate of the chunk
-+     * @param z the z coordinate of the chunk
-+     * @return a new ChunkData for the world
-+     *
-+     */
-+    @NotNull
-+    public ChunkData createVanillaChunkData(@NotNull World world, int x, int z) {
-+        return Bukkit.getServer().createVanillaChunkData(world, x, z);
-+    }
-+    // Paper end
-+
-     /**
-      * Data for a Chunk.
-      */

patches/unapplied/server/Allow-delegation-to-vanilla-chunk-gen.patch

@@ -1,67 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MiniDigger | Martin <admin@minidigger.dev>
-Date: Wed, 29 Apr 2020 02:10:32 +0200
-Subject: [PATCH] Allow delegation to vanilla chunk gen
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         return new OldCraftChunkData(world);
-     }
- 
-+    // Paper start
-+    @Override
-+    public ChunkGenerator.ChunkData createVanillaChunkData(World world, int x, int z) {
-+        // get empty object
-+        OldCraftChunkData data = (OldCraftChunkData) createChunkData(world);
-+        // do bunch of vanilla shit
-+        net.minecraft.server.level.ServerLevel nmsWorld = ((CraftWorld) world).getHandle();
-+        net.minecraft.world.level.chunk.ProtoChunk protoChunk = new net.minecraft.world.level.chunk.ProtoChunk(new net.minecraft.world.level.ChunkPos(x, z), null, nmsWorld, nmsWorld);
-+        List<net.minecraft.world.level.chunk.ChunkAccess> list = new ArrayList<>();
-+        list.add(protoChunk);
-+        net.minecraft.server.level.WorldGenRegion genRegion = new net.minecraft.server.level.WorldGenRegion(nmsWorld, list, net.minecraft.world.level.chunk.ChunkStatus.EMPTY, -1);
-+        // call vanilla generator, one feature after another. Order here is important!
-+        net.minecraft.world.level.chunk.ChunkGenerator chunkGenerator = nmsWorld.getChunkSource().generator;
-+        if (chunkGenerator instanceof org.bukkit.craftbukkit.generator.CustomChunkGenerator) {
-+            chunkGenerator = ((org.bukkit.craftbukkit.generator.CustomChunkGenerator) chunkGenerator).delegate;
-+        }
-+        chunkGenerator.createBiomes(nmsWorld.registryAccess().registryOrThrow(Registry.BIOME_REGISTRY), protoChunk);
-+        chunkGenerator.fillFromNoise((runnable) -> {}, nmsWorld.structureFeatureManager(), protoChunk);
-+        chunkGenerator.buildSurfaceAndBedrock(genRegion, protoChunk);
-+        // copy over generated sections
-+        data.setRawChunkData(protoChunk.getSections());
-+        // hooray!
-+        return data;
-+    }
-+    // Paper end
-+
-     @Override
-     public BossBar createBossBar(String title, BarColor color, BarStyle style, BarFlag... flags) {
-         return new CraftBossBar(title, color, style, flags);
-diff --git a/src/main/java/org/bukkit/craftbukkit/generator/OldCraftChunkData.java b/src/main/java/org/bukkit/craftbukkit/generator/OldCraftChunkData.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/generator/OldCraftChunkData.java
-+++ b/src/main/java/org/bukkit/craftbukkit/generator/OldCraftChunkData.java
-@@ -0,0 +0,0 @@ import org.bukkit.material.MaterialData;
- public final class OldCraftChunkData implements ChunkGenerator.ChunkData {
-     private final int minHeight;
-     private final int maxHeight;
--    private final LevelChunkSection[] sections;
-+    private LevelChunkSection[] sections;
-     private Set<BlockPos> tiles;
-     private final Set<BlockPos> lights = new HashSet<>();
-     private World world; // Paper - Anti-Xray - Add parameters
-@@ -0,0 +0,0 @@ public final class OldCraftChunkData implements ChunkGenerator.ChunkData {
-     Set<BlockPos> getLights() {
-         return this.lights;
-     }
-+
-+    // Paper start
-+    public void setRawChunkData(LevelChunkSection[] sections) {
-+        this.sections = sections;
-+    }
-+    // Paper end
- }

patches/unapplied/server/Remove-some-streams-from-structures.patch

@@ -1,106 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Josh Roy <10731363+JRoy@users.noreply.github.com>
-Date: Mon, 29 Jun 2020 17:03:06 -0400
-Subject: [PATCH] Remove some streams from structures
-
-This showed up a lot in the spark profiler, should have a low-medium performance improvement.
-
-diff --git a/src/main/java/net/minecraft/world/level/StructureFeatureManager.java b/src/main/java/net/minecraft/world/level/StructureFeatureManager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/StructureFeatureManager.java
-+++ b/src/main/java/net/minecraft/world/level/StructureFeatureManager.java
-@@ -0,0 +0,0 @@ public class StructureFeatureManager {
-         });
-     }
- 
-+    // Paper start - remove structure streams - based on method above
-+    public java.util.List<StructureStart<?>> streamlessStartsForFeature(SectionPos sectionPosition, StructureFeature<?> structureGenerator) {
-+        java.util.List<StructureStart<?>> list = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>();
-+        for (Long curLong : this.level.getChunk(sectionPosition.x(), sectionPosition.z(), ChunkStatus.STRUCTURE_REFERENCES).getReferencesForFeature(structureGenerator)) {
-+            SectionPos sectionPosition1 = SectionPos.of(new ChunkPos(curLong), 0);
-+            StructureStart<?> structurestart = getStartForFeature(sectionPosition1, structureGenerator, this.level.getChunk(sectionPosition1.x(), sectionPosition1.z(), ChunkStatus.STRUCTURE_STARTS));
-+            if (structurestart != null && structurestart.isValid()) {
-+                list.add(structurestart);
-+            }
-+        }
-+        return list;
-+    }
-+    // Paper end
-+
-     @Nullable
-     public StructureStart<?> getStartForFeature(SectionPos pos, StructureFeature<?> feature, FeatureAccess holder) {
-         return holder.getStartForFeature(feature);
-@@ -0,0 +0,0 @@ public class StructureFeatureManager {
-     }
- 
-     public StructureStart<?> getStructureAt(BlockPos pos, boolean matchChildren, StructureFeature<?> feature) {
--        return (StructureStart) DataFixUtils.orElse(this.startsForFeature(SectionPos.of(pos), feature).filter((structurestart) -> {
--            return matchChildren ? structurestart.getPieces().stream().anyMatch((structurepiece) -> {
--                return structurepiece.getBoundingBox().isInside((Vec3i) pos);
--            }) : structurestart.getBoundingBox().isInside((Vec3i) pos);
--        }).findFirst(), StructureStart.INVALID_START);
-+        // Paper start - remove structure streams
-+        for (StructureStart<?> structureStart : streamlessStartsForFeature(SectionPos.of(pos), feature)) {
-+            if (matchChildren) {
-+                for (net.minecraft.world.level.levelgen.structure.StructurePiece piece : structureStart.getPieces()) {
-+                    if (piece.getBoundingBox().isInside(pos)) {
-+                        return structureStart;
-+                    }
-+                }
-+            } else if (structureStart.getBoundingBox().isInside(pos)) {
-+                return structureStart;
-+            }
-+        }
-+        return StructureStart.INVALID_START;
-+        // Paper end
-     }
- 
-     // Spigot start
-diff --git a/src/main/java/net/minecraft/world/level/biome/Biome.java b/src/main/java/net/minecraft/world/level/biome/Biome.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/biome/Biome.java
-+++ b/src/main/java/net/minecraft/world/level/biome/Biome.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.level.levelgen.WorldgenRandom;
- import net.minecraft.world.level.levelgen.feature.ConfiguredFeature;
- import net.minecraft.world.level.levelgen.feature.StructureFeature;
- import net.minecraft.world.level.levelgen.structure.BoundingBox;
-+import net.minecraft.world.level.levelgen.structure.StructureStart;
- import net.minecraft.world.level.levelgen.surfacebuilders.ConfiguredSurfaceBuilder;
- import net.minecraft.world.level.levelgen.synth.PerlinSimplexNoise;
- import net.minecraft.world.level.material.FluidState;
-@@ -0,0 +0,0 @@ public final class Biome {
-                         int p = region.getMinBuildHeight() + 1;
-                         int q = region.getMaxBuildHeight() - 1;
-                         region.setCurrentlyGenerating(supplier);
--                        structureAccessor.startsForFeature(SectionPos.of(origin), structureFeature).forEach((structureStart) -> {
-+                        // Paper start - remove structure streams
-+                        for (StructureStart<?> structureStart : structureAccessor.streamlessStartsForFeature(SectionPos.of(origin), structureFeature)) {
-                             structureStart.placeInChunk(region, structureAccessor, chunkGenerator, random, new BoundingBox(n, p, o, n + 15, q, o + 15), new ChunkPos(l, m));
--                        });
-+                        }
-+                        // Paper end
-                     } catch (Exception var24) {
-                         CrashReport crashReport = CrashReport.forThrowable(var24, "Feature placement");
-                         crashReport.addCategory("Feature").setDetail("Description", supplier::get);
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/Beardifier.java b/src/main/java/net/minecraft/world/level/levelgen/Beardifier.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/levelgen/Beardifier.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/Beardifier.java
-@@ -0,0 +0,0 @@ public class Beardifier {
-         this.rigids = new ObjectArrayList<>(10);
- 
-         for(StructureFeature<?> structureFeature : StructureFeature.NOISE_AFFECTING_FEATURES) {
--            accessor.startsForFeature(SectionPos.bottomOf(chunk), structureFeature).forEach((start) -> {
-+            for (net.minecraft.world.level.levelgen.structure.StructureStart<?> start : accessor.streamlessStartsForFeature(SectionPos.of(chunkPos, 0), structureFeature)) { // Paper - remove structure streams
-                 for(StructurePiece structurePiece : start.getPieces()) {
-                     if (structurePiece.isCloseToChunk(chunkPos, 12)) {
-                         if (structurePiece instanceof PoolElementStructurePiece) {
-@@ -0,0 +0,0 @@ public class Beardifier {
-                     }
-                 }
- 
--            });
-+            } // Paper - remove structure streams
-         }
- 
-         this.pieceIterator = this.rigids.iterator();