patches and remap fixes

patches/server/Add-BellRevealRaiderEvent.patch

@@ -10,8 +10,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/world/level/block/entity/BellBlockEntity.java
 @@ -0,0 +0,0 @@ public class BellBlockEntity extends BlockEntity {
      private static void makeRaidersGlow(Level world, BlockPos pos, List<LivingEntity> hearingEntities) {
-         hearingEntities.stream().filter((livingEntity) -> {
-             return isRaiderWithinRange(pos, livingEntity);
+         hearingEntities.stream().filter((entity) -> {
+             return isRaiderWithinRange(pos, entity);
 -        }).forEach(BellBlockEntity::glow);
 +        }).forEach(entity -> glow(entity, pos)); // Paper - pass BlockPos
      }
@@ -24,7 +24,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -    private static void glow(LivingEntity entity) {
 +    // Paper start
 +    private static void glow(LivingEntity entity) { glow(entity, null); }
-+    private static void glow(LivingEntity entity, BlockPos pos) {
++    private static void glow(LivingEntity entity, @javax.annotation.Nullable BlockPos pos) {
 +        if (pos != null && !new io.papermc.paper.event.block.BellRevealRaiderEvent(entity.level.getWorld().getBlockAt(net.minecraft.server.MCUtil.toLocation(entity.level, pos)), entity.getBukkitEntity()).callEvent()) return;
 +        // Paper end
          entity.addEffect(new MobEffectInstance(MobEffects.GLOWING, 60));

patches/server/Add-option-to-fix-items-merging-through-walls.patch

@@ -18,7 +18,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        fixItemsMergingThroughWalls = getBoolean("fix-items-merging-through-walls", fixItemsMergingThroughWalls);
 +    }
  }
- 
 diff --git a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java

patches/server/MC-Dev-fixes.patch

@@ -305,3 +305,39 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public static class BiomeBuilder {
          @Nullable
          private Biome.Precipitation precipitation;
+diff --git a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
++++ b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
+@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
+     }
+ 
+     static record Configuration<T>(Palette.Factory factory, int bits) {
+-        Configuration(Palette.Factory factory, int i) {
+-            this.factory = factory;
+-            this.bits = i;
+-        }
+ 
+         public PalettedContainer.Data<T> createData(IdMap<T> idList, PaletteResize<T> listener, int size) {
+             BitStorage bitStorage = (BitStorage)(this.bits == 0 ? new ZeroBitStorage(size) : new SimpleBitStorage(this.bits, size));
+@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
+     }
+ 
+     static record Data<T>(PalettedContainer.Configuration<T> configuration, BitStorage storage, Palette<T> palette) {
+-        final BitStorage storage;
+-        final Palette<T> palette;
+-
+         public void copyFrom(Palette<T> palette, BitStorage storage) {
+             for(int i = 0; i < storage.getSize(); ++i) {
+                 T object = palette.valueFor(storage.get(i));
+@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
+     }
+ 
+     static record DiscData<T>(List<T> paletteEntries, Optional<LongStream> storage) {
+-        DiscData(List<T> list, Optional<LongStream> optional) {
+-            this.paletteEntries = list;
+-            this.storage = optional;
+-        }
+     }
+ 
+     public abstract static class Strategy {

patches/server/Synchronize-PalettedContainer-instead-of-ReentrantLo.patch

@@ -0,0 +1,91 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Fri, 29 May 2020 20:29:02 -0400
+Subject: [PATCH] Synchronize PalettedContainer instead of ReentrantLock
+
+Mojang has flaws in their logic about chunks being concurrently
+wrote to. So we constantly see crashes around multiple threads writing.
+
+Additionally, java has optimized synchronization so well that its
+in many times faster than trying to manage read wrote locks for low
+contention situations.
+
+And this is extremely a low contention situation.
+
+diff --git a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
++++ b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
+@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
+     private final ThreadingDetector threadingDetector = new ThreadingDetector("PalettedContainer");
+ 
+     public void acquire() {
+-        this.threadingDetector.checkAndLock();
++        // this.threadingDetector.checkAndLock(); // Paper - disable this - use proper synchronization
+     }
+ 
+     public void release() {
+-        this.threadingDetector.checkAndUnlock();
++        // this.threadingDetector.checkAndUnlock(); // Paper - disable this
+     }
+ 
+     public static <T> Codec<PalettedContainer<T>> codec(IdMap<T> idList, Codec<T> entryCodec, PalettedContainer.Strategy provider, T object) {
+-        return RecordCodecBuilder.create((instance) -> {
++        return RecordCodecBuilder.<DiscData<T>>create((instance) -> { // Paper - decompile fixes
+             return instance.group(entryCodec.mapResult(ExtraCodecs.orElsePartial(object)).listOf().fieldOf("palette").forGetter(PalettedContainer.DiscData::paletteEntries), Codec.LONG_STREAM.optionalFieldOf("data").forGetter(PalettedContainer.DiscData::storage)).apply(instance, PalettedContainer.DiscData::new);
+         }).comapFlatMap((serialized) -> {
+             return read(idList, provider, serialized);
+@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
+         return data2.palette.idFor(object);
+     }
+ 
+-    public T getAndSet(int x, int y, int z, T value) {
++    public synchronized T getAndSet(int x, int y, int z, T value) { // Paper - synchronize
+         this.acquire();
+ 
+         Object var5;
+@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
+         return this.data.palette.valueFor(j);
+     }
+ 
+-    public void set(int x, int y, int z, T value) {
++    public synchronized void set(int x, int y, int z, T value) { // Paper - synchronize
+         this.acquire();
+ 
+         try {
+@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
+         });
+     }
+ 
+-    public void read(FriendlyByteBuf buf) {
++    public synchronized void read(FriendlyByteBuf buf) { // Paper - synchronize
+         this.acquire();
+ 
+         try {
+@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
+ 
+     }
+ 
+-    public void write(FriendlyByteBuf buf) {
++    public synchronized void write(FriendlyByteBuf buf) { // Paper - synchronize
+         this.acquire();
+ 
+         try {
+@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
+ 
+     }
+ 
+-    private static <T> DataResult<PalettedContainer<T>> read(IdMap<T> idList, PalettedContainer.Strategy provider, PalettedContainer.DiscData<T> serialized) {
++    private static synchronized <T> DataResult<PalettedContainer<T>> read(IdMap<T> idList, PalettedContainer.Strategy provider, PalettedContainer.DiscData<T> serialized) { // Paper - synchronize
+         List<T> list = serialized.paletteEntries();
+         int i = provider.size();
+         int j = provider.calculateBitsForSerialization(idList, list.size());
+@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
+         return DataResult.success(new PalettedContainer<>(idList, provider, configuration, bitStorage, list));
+     }
+ 
+-    private PalettedContainer.DiscData<T> write(IdMap<T> idList, PalettedContainer.Strategy provider) {
++    private synchronized PalettedContainer.DiscData<T> write(IdMap<T> idList, PalettedContainer.Strategy provider) { // Paper - synchronize
+         this.acquire();
+ 
+         PalettedContainer.DiscData var12;

patches/unapplied/server/Synchronize-PalettedContainer-instead-of-ReentrantLo.patch

@@ -1,92 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Fri, 29 May 2020 20:29:02 -0400
-Subject: [PATCH] Synchronize PalettedContainer instead of ReentrantLock
-
-Mojang has flaws in their logic about chunks being concurrently
-wrote to. So we constantly see crashes around multiple threads writing.
-
-Additionally, java has optimized synchronization so well that its
-in many times faster than trying to manage read wrote locks for low
-contention situations.
-
-And this is extremely a low contention situation.
-
-diff --git a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
-@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
-     private final DebugBuffer<Pair<Thread, StackTraceElement[]>> traces = null;
- 
-     public void acquire() {
-+        /* // Paper start - disable this - use proper synchronization
-         if (this.traces != null) {
-             Thread thread = Thread.currentThread();
-             this.traces.push(Pair.of(thread, thread.getStackTrace()));
-         }
- 
-         ThreadingDetector.checkAndLock(this.lock, this.traces, "PalettedContainer");
-+        */ // Paper end
-     }
- 
-     public void release() {
--        this.lock.release();
-+        //this.lock.release(); // Paper - disable this
-     }
- 
-     // Paper start - Anti-Xray - Add preset values
-@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
-         return this.palette.idFor(objectAdded);
-     }
- 
--    public T getAndSet(int x, int y, int z, T value) {
-+    public synchronized T getAndSet(int x, int y, int z, T value) { // Paper - synchronize
-         Object var6;
-         try {
-             this.acquire();
-@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
-         return (T)(object == null ? this.defaultValue : object);
-     }
- 
--    public void set(int i, int j, int k, T object) {
-+    public synchronized void set(int i, int j, int k, T object) { // Paper - synchronize
-         try {
-             this.acquire();
-             this.set(getIndex(i, j, k), object);
-@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
-         return (T)(object == null ? this.defaultValue : object);
-     }
- 
--    public void read(FriendlyByteBuf buf) {
-+    public synchronized void read(FriendlyByteBuf buf) { // Paper - synchronize
-         try {
-             this.acquire();
-             int i = buf.readByte();
-@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
- 
-     // Paper start - Anti-Xray - Add chunk packet info
-     @Deprecated public void write(FriendlyByteBuf buf) { write(buf, null, 0); } // Notice for updates: Please make sure this method isn't used anywhere
--    public void write(FriendlyByteBuf buf, com.destroystokyo.paper.antixray.ChunkPacketInfo<T> chunkPacketInfo, int bottomBlockY) {
-+    public synchronized void write(FriendlyByteBuf buf, com.destroystokyo.paper.antixray.ChunkPacketInfo<T> chunkPacketInfo, int bottomBlockY) { // Paper - synchronize
-         // Paper end
-         try {
-             this.acquire();
-@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
- 
-     }
- 
--    public void read(ListTag paletteNbt, long[] data) {
-+    public synchronized void read(ListTag paletteNbt, long[] data) { // Paper - synchronize
-         try {
-             this.acquire();
-             // Paper - Anti-Xray - TODO: Should this.presetValues.length just be added here (faster) or should the contents be compared to calculate the size (less RAM)?
-@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
- 
-     }
- 
--    public void write(CompoundTag nbt, String paletteKey, String dataKey) {
-+    public synchronized void write(CompoundTag nbt, String paletteKey, String dataKey) { // Paper - synchronize
-         try {
-             this.acquire();
-             HashMapPalette<T> hashMapPalette = new HashMapPalette<>(this.registry, this.bits, this.dummyPaletteResize, this.reader, this.writer);