a bunch more patches done

patches/server/Add-permission-for-command-blocks.patch

@@ -24,19 +24,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
          PacketUtils.ensureRunningOnSameThread(packet, this, this.player.getLevel());
          if (!this.server.isCommandBlockEnabled()) {
-             this.player.sendMessage(new TranslatableComponent("advMode.notEnabled"), Util.NIL_UUID);
+             this.player.sendSystemMessage(Component.translatable("advMode.notEnabled"));
 -        } else if (!this.player.canUseGameMasterBlocks()) {
 +        } else if (!this.player.canUseGameMasterBlocks() && (!this.player.isCreative() || !this.player.getBukkitEntity().hasPermission("minecraft.commandblock"))) { // Paper - command block permission
-             this.player.sendMessage(new TranslatableComponent("advMode.notAllowed"), Util.NIL_UUID);
+             this.player.sendSystemMessage(Component.translatable("advMode.notAllowed"));
          } else {
              BaseCommandBlock commandblocklistenerabstract = null;
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
          PacketUtils.ensureRunningOnSameThread(packet, this, this.player.getLevel());
          if (!this.server.isCommandBlockEnabled()) {
-             this.player.sendMessage(new TranslatableComponent("advMode.notEnabled"), Util.NIL_UUID);
+             this.player.sendSystemMessage(Component.translatable("advMode.notEnabled"));
 -        } else if (!this.player.canUseGameMasterBlocks()) {
 +        } else if (!this.player.canUseGameMasterBlocks() && (!this.player.isCreative() || !this.player.getBukkitEntity().hasPermission("minecraft.commandblock"))) { // Paper - command block permission
-             this.player.sendMessage(new TranslatableComponent("advMode.notAllowed"), Util.NIL_UUID);
+             this.player.sendSystemMessage(Component.translatable("advMode.notAllowed"));
          } else {
              BaseCommandBlock commandblocklistenerabstract = packet.getCommandBlock(this.player.level);
 diff --git a/src/main/java/net/minecraft/world/level/BaseCommandBlock.java b/src/main/java/net/minecraft/world/level/BaseCommandBlock.java

patches/server/Deobfuscate-stacktraces-in-log-messages-crash-report.patch

@@ -23,7 +23,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    annotationProcessor("org.apache.logging.log4j:log4j-core:2.14.1") // Paper - Needed to generate meta for our Log4j plugins
      // Paper end
      implementation("org.apache.logging.log4j:log4j-iostreams:2.17.1") // Paper
-     implementation("org.ow2.asm:asm:9.2")
+     implementation("org.ow2.asm:asm:9.3")
 @@ -0,0 +0,0 @@ dependencies {
      runtimeOnly("org.apache.maven.resolver:maven-resolver-connector-basic:1.7.2")
      runtimeOnly("org.apache.maven.resolver:maven-resolver-transport-http:1.7.2")

patches/server/Ensure-Entity-AABB-s-are-never-invalid.patch

@@ -32,7 +32,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.position = new Vec3(x, y, z);
              int i = Mth.floor(x);
 @@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
-             }
+             this.levelCallback.onMove();
          }
  
 +        // Paper start - never allow AABB to become desynced from position

patches/server/Fix-Per-World-Difficulty-Remembering-Difficulty.patch

@@ -59,7 +59,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          } else {
 -            worldServer.serverLevelData.setDifficulty(difficulty); // CraftBukkit
 +            minecraftserver.setDifficulty(worldServer, difficulty, true); // Paper - don't skip other difficulty-changing logic (fix upstream's fix)
-             source.sendSuccess(new TranslatableComponent("commands.difficulty.success", new Object[]{difficulty.getDisplayName()}), true);
+             source.sendSuccess(Component.translatable("commands.difficulty.success", difficulty.getDisplayName()), true);
              return 0;
          }
 diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
@@ -71,7 +71,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public void forceDifficulty() {
 -        this.setDifficulty(this.getProperties().difficulty, true);
-+        //this.a(this.getDedicatedServerProperties().difficulty, true); // Paper - Don't overwrite level.dat's difficulty, keep current
++        // this.setDifficulty(this.getProperties().difficulty, true); // Paper - Don't overwrite level.dat's difficulty, keep current
      }
  
      @Override
@@ -82,7 +82,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
                  this.isChangingDimension = true; // CraftBukkit - Set teleport invulnerability only if player changing worlds
  
-                 this.connection.send(new ClientboundRespawnPacket(worldserver.dimensionTypeRegistration(), worldserver.dimension(), BiomeManager.obfuscateSeed(worldserver.getSeed()), this.gameMode.getGameModeForPlayer(), this.gameMode.getPreviousGameModeForPlayer(), worldserver.isDebug(), worldserver.isFlat(), true));
+                 this.connection.send(new ClientboundRespawnPacket(worldserver.dimensionTypeId(), worldserver.dimension(), BiomeManager.obfuscateSeed(worldserver.getSeed()), this.gameMode.getGameModeForPlayer(), this.gameMode.getPreviousGameModeForPlayer(), worldserver.isDebug(), worldserver.isFlat(), true, this.getLastDeathLocation()));
 -                this.connection.send(new ClientboundChangeDifficultyPacket(this.level.getDifficulty(), this.level.getLevelData().isDifficultyLocked()));
 +                this.connection.send(new ClientboundChangeDifficultyPacket(worldserver.getDifficulty(), this.level.getLevelData().isDifficultyLocked())); // Paper - fix difficulty sync issue
                  PlayerList playerlist = this.server.getPlayerList();
@@ -97,7 +97,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          PacketUtils.ensureRunningOnSameThread(packet, this, this.player.getLevel());
          if (this.player.hasPermissions(2) || this.isSingleplayerOwner()) {
 -            this.server.setDifficulty(packet.getDifficulty(), false);
-+            //this.minecraftServer.a(packetplayindifficultychange.b(), false); // Paper - don't allow clients to change this
++            // this.server.setDifficulty(packet.getDifficulty(), false); // Paper - don't allow clients to change this
          }
      }
  

patches/server/Optimize-anyPlayerCloseEnoughForSpawning-to-use-dist.patch

@@ -367,4 +367,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    public double lastEntitySpawnRadiusSquared; // Paper - optimise isOutsideRange, this field is in blocks
      public final com.destroystokyo.paper.util.misc.PooledLinkedHashSets.PooledObjectLinkedOpenHashSet<ServerPlayer> cachedSingleHashSet; // Paper
  
-     public ServerPlayer(MinecraftServer server, ServerLevel world, GameProfile profile) {
+     public ServerPlayer(MinecraftServer server, ServerLevel world, GameProfile profile, @Nullable ProfilePublicKey publicKey) {

patches/server/Protect-Bedrock-and-End-Portal-Frames-from-being-des.patch

@@ -148,15 +148,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      /** @deprecated */
 @@ -0,0 +0,0 @@ public abstract class BlockBehaviour {
-         public Block getBlock() {
-             return (Block) this.owner;
+             return ((Block) this.owner).builtInRegistryHolder();
          }
--
+ 
 +        // Paper start
 +        public final boolean isDestroyable() {
 +            return getBlock().isDestroyable();
 +        }
 +        // Paper end
++
          public Material getMaterial() {
              return this.material;
          }

patches/server/Reduce-allocation-of-Vec3D-by-entity-tracker.patch

@@ -0,0 +1,26 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <spottedleaf@spottedleaf.dev>
+Date: Mon, 27 Apr 2020 00:04:16 -0700
+Subject: [PATCH] Reduce allocation of Vec3D by entity tracker
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
++++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
+@@ -0,0 +0,0 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+         public void updatePlayer(ServerPlayer player) {
+             org.spigotmc.AsyncCatcher.catchOp("player tracker update"); // Spigot
+             if (player != this.entity) {
+-                Vec3 vec3d = player.position().subtract(this.entity.position());
++                // Paper start - remove allocation of Vec3D here
++                // Vec3 vec3d = player.position().subtract(this.entity.position());
++                double vec3d_dx = player.getX() - this.entity.getX();
++                double vec3d_dz = player.getZ() - this.entity.getZ();
++                // Paper end - remove allocation of Vec3D here
+                 double d0 = (double) Math.min(this.getEffectiveRange(), (ChunkMap.this.viewDistance - 1) * 16);
+-                double d1 = vec3d.x * vec3d.x + vec3d.z * vec3d.z;
++                double d1 = vec3d_dx * vec3d_dx + vec3d_dz * vec3d_dz; // Paper
+                 double d2 = d0 * d0;
+                 boolean flag = d1 <= d2 && this.entity.broadcastToPlayer(player);
+ 

patches/server/Use-distance-map-to-optimise-entity-tracker.patch

@@ -237,7 +237,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          Iterator iterator;
          Entity entity1;
 @@ -0,0 +0,0 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
-             this.lastSectionPos = SectionPos.of(entity);
+             this.lastSectionPos = SectionPos.of((EntityAccess) entity);
          }
  
 +        // Paper start - use distance map to optimise tracker

patches/server/Use-seed-based-lookup-for-Treasure-Maps-Fixes-lag-fr.patch

@@ -20,8 +20,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
                  for (j1 = 0; j1 < 128; ++j1) {
                      for (k1 = 0; k1 < 128; ++k1) {
--                        Biome.BiomeCategory biomebase_geography = Biome.getBiomeCategory(world.getBiome(blockposition_mutableblockposition.set((l + k1) * i, 0, (i1 + j1) * i)));
-+                        Biome.BiomeCategory biomebase_geography = Biome.getBiomeCategory(world.getUncachedNoiseBiome((l + k1) * i, 0, (i1 + j1) * i)); // Paper
+-                        Holder<Biome> holder = world.getBiome(blockposition_mutableblockposition.set((l + k1) * i, 0, (i1 + j1) * i));
++                        Holder<Biome> holder = world.getUncachedNoiseBiome((l + k1) * i, 0, (i1 + j1) * i); // Paper
  
-                         aboolean[j1 * 128 + k1] = biomebase_geography == Biome.BiomeCategory.OCEAN || biomebase_geography == Biome.BiomeCategory.RIVER || biomebase_geography == Biome.BiomeCategory.SWAMP;
+                         aboolean[j1 * 128 + k1] = holder.is(BiomeTags.WATER_ON_MAP_OUTLINES);
                      }

patches/server/misc-debugging-dumps.patch

@@ -64,15 +64,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener
              } catch (Exception exception) {
                  ServerLoginPacketListenerImpl.LOGGER.error("Couldn't place player in world", exception);
-                 TranslatableComponent chatmessage = new TranslatableComponent("multiplayer.disconnect.invalid_player_data");
+                 MutableComponent ichatmutablecomponent = Component.translatable("multiplayer.disconnect.invalid_player_data");
 +                // Paper start
 +                if (MinecraftServer.getServer().isDebugging()) {
 +                    exception.printStackTrace();
 +                }
 +                // Paper end
  
-                 this.connection.send(new ClientboundDisconnectPacket(chatmessage));
-                 this.connection.disconnect(chatmessage);
+                 this.connection.send(new ClientboundDisconnectPacket(ichatmutablecomponent));
+                 this.connection.disconnect(ichatmutablecomponent);
 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

patches/unapplied/server/Fix-missing-chunks-due-to-integer-overflow.patch

@@ -1,27 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: David Slovikosky <davidslovikosky@gmail.com>
-Date: Tue, 9 Jun 2020 00:10:03 -0700
-Subject: [PATCH] Fix missing chunks due to integer overflow
-
-This patch fixes a bug in the WorldChunkManagerTheEnd class where the distance
-from 0,0 squared overflows the maximum size of an integer. The overflow leads
-to hard chunk borders around 370,000 blocks from 0,0. After this cutoff there
-is a few hundred thousand block gap before end land resuming to generate at
-530,000 blocks from spawn. This is due to the integer flipping back and forth.
-
-The fix for the issue is quite simple, casting chunk coordinates to longs
-allows the distance calculation to avoid overflow and work as intended.
-
-diff --git a/src/main/java/net/minecraft/world/level/biome/TheEndBiomeSource.java b/src/main/java/net/minecraft/world/level/biome/TheEndBiomeSource.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/biome/TheEndBiomeSource.java
-+++ b/src/main/java/net/minecraft/world/level/biome/TheEndBiomeSource.java
-@@ -0,0 +0,0 @@ public class TheEndBiomeSource extends BiomeSource {
-         int l = j / 2;
-         int m = i % 2;
-         int n = j % 2;
--        float f = 100.0F - Mth.sqrt((float)(i * i + j * j)) * 8.0F;
-+        float f = 100.0F - Mth.sqrt((long) i * (long) i + (long) j * (long) j) * 8.0F; // Paper - cast ints to long to avoid integer overflow
-         f = Mth.clamp(f, -100.0F, 80.0F);
- 
-         for(int o = -12; o <= 12; ++o) {

patches/unapplied/server/Reduce-allocation-of-Vec3D-by-entity-tracker.patch

@@ -1,60 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <spottedleaf@spottedleaf.dev>
-Date: Mon, 27 Apr 2020 00:04:16 -0700
-Subject: [PATCH] Reduce allocation of Vec3D by entity tracker
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ChunkMap.java
-+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
-@@ -0,0 +0,0 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
-         public void updatePlayer(ServerPlayer player) {
-             org.spigotmc.AsyncCatcher.catchOp("player tracker update"); // Spigot
-             if (player != this.entity) {
--                Vec3 vec3d = player.position().subtract(this.entity.position()); // MC-155077, SPIGOT-5113
-+                // Paper start - remove allocation of Vec3D here
-+                //Vec3 vec3d = player.position().subtract(this.entity.position()); // MC-155077, SPIGOT-5113
-+                double vec3d_dx = player.getX() - this.entity.getX();
-+                double vec3d_dz = player.getZ() - this.entity.getZ();
-+                // Paper end - remove allocation of Vec3D here
-                 double d0 = (double) Math.min(this.getEffectiveRange(), (ChunkMap.this.viewDistance - 1) * 16);
--                double d1 = vec3d.x * vec3d.x + vec3d.z * vec3d.z;
-+                double d1 = vec3d_dx * vec3d_dx + vec3d_dz * vec3d_dz; // Paper
-                 double d2 = d0 * d0;
-                 boolean flag = d1 <= d2 && this.entity.broadcastToPlayer(player);
- 
-diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerEntity.java
-+++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
-@@ -0,0 +0,0 @@ public class ServerEntity {
-                 ++this.teleportDelay;
-                 i = Mth.floor(this.entity.getYRot() * 256.0F / 360.0F);
-                 j = Mth.floor(this.entity.getXRot() * 256.0F / 360.0F);
--                Vec3 vec3d = this.entity.position().subtract(ClientboundMoveEntityPacket.packetToEntity(this.xp, this.yp, this.zp));
--                boolean flag1 = vec3d.lengthSqr() >= 7.62939453125E-6D;
-+                // Paper start - reduce allocation of Vec3D here
-+                double vec3d_dx = this.entity.getX() - 2.44140625E-4D*(this.xp);
-+                double vec3d_dy = this.entity.getY() - 2.44140625E-4D*(this.yp);
-+                double vec3d_dz = this.entity.getZ() - 2.44140625E-4D*(this.zp);
-+                boolean flag1 = (vec3d_dx * vec3d_dx + vec3d_dy * vec3d_dy + vec3d_dz * vec3d_dz) >= 7.62939453125E-6D;
-+                // Paper end - reduce allocation of Vec3D here
-                 Packet<?> packet1 = null;
-                 boolean flag2 = flag1 || this.tickCount % 60 == 0;
-                 boolean flag3 = Math.abs(i - this.yRotp) >= 1 || Math.abs(j - this.xRotp) >= 1;
-@@ -0,0 +0,0 @@ public class ServerEntity {
-                 // CraftBukkit end
- 
-                 if (this.tickCount > 0 || this.entity instanceof AbstractArrow) {
--                    long k = ClientboundMoveEntityPacket.entityToPacket(vec3d.x);
--                    long l = ClientboundMoveEntityPacket.entityToPacket(vec3d.y);
--                    long i1 = ClientboundMoveEntityPacket.entityToPacket(vec3d.z);
-+                    // Paper start - remove allocation of Vec3D here
-+                    long k = ClientboundMoveEntityPacket.entityToPacket(vec3d_dx);
-+                    long l = ClientboundMoveEntityPacket.entityToPacket(vec3d_dy);
-+                    long i1 = ClientboundMoveEntityPacket.entityToPacket(vec3d_dz);
-+                    // Paper end - remove allocation of Vec3D here
-                     boolean flag4 = k < -32768L || k > 32767L || l < -32768L || l > 32767L || i1 < -32768L || i1 > 32767L;
- 
-                     if (!flag4 && this.teleportDelay <= 400 && !this.wasRiding && this.wasOnGround == this.entity.isOnGround()) {