finish some more patches

patches/server/Add-API-for-quit-reason.patch

@@ -8,6 +8,24 @@ diff --git a/src/main/java/net/minecraft/network/Connection.java b/src/main/java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/network/Connection.java
 +++ b/src/main/java/net/minecraft/network/Connection.java
+@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
+         this.receiving = side;
+     }
+ 
++    // Paper start
++    @Nullable
++    public net.minecraft.server.level.ServerPlayer getPlayer() {
++        if (this.packetListener instanceof net.minecraft.server.network.ServerGamePacketListenerImpl serverGamePacketListener) {
++            return serverGamePacketListener.player;
++        } else {
++            return null;
++        }
++    }
++    // Paper end
++
+     public void channelActive(ChannelHandlerContext channelhandlercontext) throws Exception {
+         super.channelActive(channelhandlercontext);
+         this.channel = channelhandlercontext.channel();
 @@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
  
              this.handlingFault = true;
@@ -29,7 +47,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
 +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
 @@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-     public double lastEntitySpawnRadiusSquared; // Paper - optimise isOutsideRange, this field is in blocks
+     public boolean isRealPlayer; // Paper
      public final com.destroystokyo.paper.util.misc.PooledLinkedHashSets.PooledObjectLinkedOpenHashSet<ServerPlayer> cachedSingleHashSet; // Paper
      public PlayerNaturallySpawnCreaturesEvent playerNaturallySpawnedEvent; // Paper
 +    public org.bukkit.event.player.PlayerQuitEvent.QuitReason quitReason = null; // Paper - there are a lot of changes to do if we change all methods leading to the event

patches/server/Avoid-error-bubbling-up-when-item-stack-is-empty-in-.patch

@@ -15,32 +15,32 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
                  while (iterator.hasNext()) {
                      ItemStack itemstack1 = (ItemStack) iterator.next();
--                    ItemEntity entityitem = new ItemEntity(this.level, this.getX(), this.getY(), this.getZ(), itemstack1);
+-                    ItemEntity entityitem = new ItemEntity(this.level(), this.getX(), this.getY(), this.getZ(), itemstack1);
 +                    // Paper start, new EntityItem would throw if for whatever reason (mostly shitty datapacks) the itemstack1 turns out to be empty
 +                    // if the item stack is empty we instead just have our entityitem as null
 +                    ItemEntity entityitem = null;
 +                    if (!itemstack1.isEmpty()) {
-+                        entityitem = new ItemEntity(this.level, this.getX(), this.getY(), this.getZ(), itemstack1);
++                        entityitem = new ItemEntity(this.level(), this.getX(), this.getY(), this.getZ(), itemstack1);
 +                    }
 +                    // Paper end
                      // CraftBukkit start
 -                    PlayerFishEvent playerFishEvent = new PlayerFishEvent((Player) entityhuman.getBukkitEntity(), entityitem.getBukkitEntity(), (FishHook) this.getBukkitEntity(), PlayerFishEvent.State.CAUGHT_FISH);
 +                    PlayerFishEvent playerFishEvent = new PlayerFishEvent((Player) entityhuman.getBukkitEntity(), entityitem != null ? entityitem.getBukkitEntity() : null, (FishHook) this.getBukkitEntity(), PlayerFishEvent.State.CAUGHT_FISH); // Paper - entityitem may be null
                      playerFishEvent.setExpToDrop(this.random.nextInt(6) + 1);
-                     this.level.getCraftServer().getPluginManager().callEvent(playerFishEvent);
+                     this.level().getCraftServer().getPluginManager().callEvent(playerFishEvent);
  
 @@ -0,0 +0,0 @@ public class FishingHook extends Projectile {
                      double d2 = entityhuman.getZ() - this.getZ();
                      double d3 = 0.1D;
  
 -                    entityitem.setDeltaMovement(d0 * 0.1D, d1 * 0.1D + Math.sqrt(Math.sqrt(d0 * d0 + d1 * d1 + d2 * d2)) * 0.08D, d2 * 0.1D);
--                    this.level.addFreshEntity(entityitem);
+-                    this.level().addFreshEntity(entityitem);
 +                    // Paper start, entity item can be null, so we need to check against this
 +                    if (entityitem != null) {
 +                        entityitem.setDeltaMovement(d0 * 0.1D, d1 * 0.1D + Math.sqrt(Math.sqrt(d0 * d0 + d1 * d1 + d2 * d2)) * 0.08D, d2 * 0.1D);
-+                        this.level.addFreshEntity(entityitem);
++                        this.level().addFreshEntity(entityitem);
 +                    }
 +                    // Paper end
                      // CraftBukkit start - this.random.nextInt(6) + 1 -> playerFishEvent.getExpToDrop()
                      if (playerFishEvent.getExpToDrop() > 0) {
-                         entityhuman.level.addFreshEntity(new ExperienceOrb(entityhuman.level, entityhuman.getX(), entityhuman.getY() + 0.5D, entityhuman.getZ() + 0.5D, playerFishEvent.getExpToDrop(), org.bukkit.entity.ExperienceOrb.SpawnReason.FISHING, this.getPlayerOwner(), this)); // Paper
+                         entityhuman.level().addFreshEntity(new ExperienceOrb(entityhuman.level(), entityhuman.getX(), entityhuman.getY() + 0.5D, entityhuman.getZ() + 0.5D, playerFishEvent.getExpToDrop(), org.bukkit.entity.ExperienceOrb.SpawnReason.FISHING, this.getPlayerOwner(), this)); // Paper

patches/server/Brand-support.patch

@@ -25,7 +25,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
      @Override
      public void handleCustomPayload(ServerboundCustomPayloadPacket packet) {
-         PacketUtils.ensureRunningOnSameThread(packet, this, this.player.getLevel());
+         PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel());
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
              try {
                  byte[] data = new byte[packet.data.readableBytes()];

patches/server/Buffer-joins-to-world.patch

@@ -12,8 +12,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/network/Connection.java
 +++ b/src/main/java/net/minecraft/network/Connection.java
 @@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
+         }
      }
-     // Paper end
  
 +    private static final int MAX_PER_TICK = io.papermc.paper.configuration.GlobalConfiguration.get().misc.maxJoinsPerTick; // Paper
 +    private static int joinAttemptsThisTick; // Paper

patches/server/Do-not-let-the-server-load-chunks-from-newer-version.patch

@@ -13,16 +13,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java
 +++ b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java
 @@ -0,0 +0,0 @@ public class ChunkSerializer {
-         return holder.protoChunk;
-     }
+ 
+     public ChunkSerializer() {}
  
 +    // Paper start
 +    private static final int CURRENT_DATA_VERSION = net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion();
 +    private static final boolean JUST_CORRUPT_IT = Boolean.getBoolean("Paper.ignoreWorldDataVersion");
 +    // Paper end
-     public static InProgressChunkHolder loadChunk(ServerLevel world, PoiManager poiStorage, ChunkPos chunkPos, CompoundTag nbt, boolean distinguish) {
-         java.util.ArrayDeque<Runnable> tasksToExecuteOnMain = new java.util.ArrayDeque<>();
-         // Paper end
+     public static ProtoChunk read(ServerLevel world, PoiManager poiStorage, ChunkPos chunkPos, CompoundTag nbt) {
 +        // Paper start - Do NOT attempt to load chunks saved with newer versions
 +        if (nbt.contains("DataVersion", 99)) {
 +            int dataVersion = nbt.getInt("DataVersion");
@@ -32,6 +30,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            }
 +        }
 +        // Paper end
-         ChunkPos chunkcoordintpair1 = new ChunkPos(nbt.getInt("xPos"), nbt.getInt("zPos")); // Paper - diff on change, see ChunkSerializer#getChunkCoordinate
+         ChunkPos chunkcoordintpair1 = new ChunkPos(nbt.getInt("xPos"), nbt.getInt("zPos"));
  
          if (!Objects.equals(chunkPos, chunkcoordintpair1)) {

patches/server/Fix-for-large-move-vectors-crashing-server.patch

@@ -12,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
  
              if (entity != this.player && entity.getControllingPassenger() == this.player && entity == this.lastVehicle) {
-                 ServerLevel worldserver = this.player.getLevel();
+                 ServerLevel worldserver = this.player.serverLevel();
 -                double d0 = entity.getX();
 -                double d1 = entity.getY();
 -                double d2 = entity.getZ();
@@ -56,37 +56,37 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                d8 = d5 - this.vehicleLastGoodZ; // Paper - diff on change, used for checking large move vectors above
                  boolean flag1 = entity.verticalCollisionBelow;
  
-                 entity.move(MoverType.PLAYER, new Vec3(d6, d7, d8));
+                 if (entity instanceof LivingEntity) {
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
-                         double d8 = d1 - this.firstGoodY;
-                         double d9 = d2 - this.firstGoodZ;
-                         double d10 = this.player.getDeltaMovement().lengthSqr();
--                        double d11 = d7 * d7 + d8 * d8 + d9 * d9;
+                         double d7 = d1 - this.firstGoodY;
+                         double d8 = d2 - this.firstGoodZ;
+                         double d9 = this.player.getDeltaMovement().lengthSqr();
+-                        double d10 = d6 * d6 + d7 * d7 + d8 * d8;
 +                        // Paper start - fix large move vectors killing the server
 +                        double currDeltaX = toX - prevX;
 +                        double currDeltaY = toY - prevY;
 +                        double currDeltaZ = toZ - prevZ;
-+                        double d11 = Math.max(d7 * d7 + d8 * d8 + d9 * d9, (currDeltaX * currDeltaX + currDeltaY * currDeltaY + currDeltaZ * currDeltaZ) - 1);
++                        double d10 = Math.max(d7 * d7 + d8 * d8 + d9 * d9, (currDeltaX * currDeltaX + currDeltaY * currDeltaY + currDeltaZ * currDeltaZ) - 1);
 +                        // Paper end - fix large move vectors killing the server
 +                        // Paper start - fix large move vectors killing the server
 +                        double otherFieldX = d0 - this.lastGoodX;
 +                        double otherFieldY = d1 - this.lastGoodY;
 +                        double otherFieldZ = d2 - this.lastGoodZ;
-+                        d11 = Math.max(d11, (otherFieldX * otherFieldX + otherFieldY * otherFieldY + otherFieldZ * otherFieldZ) - 1);
++                        d10 = Math.max(d10, (otherFieldX * otherFieldX + otherFieldY * otherFieldY + otherFieldZ * otherFieldZ) - 1);
 +                        // Paper end - fix large move vectors killing the server
  
                          if (this.player.isSleeping()) {
-                             if (d11 > 1.0D) {
+                             if (d10 > 1.0D) {
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
  
                              AABB axisalignedbb = this.player.getBoundingBox();
  
--                            d7 = d0 - this.lastGoodX;
--                            d8 = d1 - this.lastGoodY;
--                            d9 = d2 - this.lastGoodZ;
-+                            d7 = d0 - this.lastGoodX; // Paper - diff on change, used for checking large move vectors above
-+                            d8 = d1 - this.lastGoodY; // Paper - diff on change, used for checking large move vectors above
-+                            d9 = d2 - this.lastGoodZ; // Paper - diff on change, used for checking large move vectors above
-                             boolean flag = d8 > 0.0D;
+-                            d6 = d0 - this.lastGoodX;
+-                            d7 = d1 - this.lastGoodY;
+-                            d8 = d2 - this.lastGoodZ;
++                            d6 = d0 - this.lastGoodX; // Paper - diff on change, used for checking large move vectors above
++                            d7 = d1 - this.lastGoodY; // Paper - diff on change, used for checking large move vectors above
++                            d8 = d2 - this.lastGoodZ; // Paper - diff on change, used for checking large move vectors above
+                             boolean flag = d7 > 0.0D;
  
-                             if (this.player.isOnGround() && !packet.isOnGround() && flag) {
+                             if (this.player.onGround() && !packet.isOnGround() && flag) {

patches/server/Reduce-blockpos-allocation-from-pathfinding.patch

@@ -16,13 +16,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                        if (blockState.getFluidState().is(FluidTags.WATER)) {
                              return BlockPathTypes.WATER_BORDER;
                          }
-                         } // Paper
+ 
 @@ -0,0 +0,0 @@ public class WalkNodeEvaluator extends NodeEvaluator {
                  } else if (blockState.is(Blocks.COCOA)) {
                      return BlockPathTypes.COCOA;
-                 } else {
+                 } else if (!blockState.is(Blocks.WITHER_ROSE) && !blockState.is(Blocks.POINTED_DRIPSTONE)) {
 -                    FluidState fluidState = world.getFluidState(pos);
-+                FluidState fluidState = blockState.getFluidState(); // Paper - remove another get type call
++                    FluidState fluidState = blockState.getFluidState(); // Paper - remove another getFluidState call
                      if (fluidState.is(FluidTags.LAVA)) {
                          return BlockPathTypes.LAVA;
                      } else if (isBurningBlock(blockState)) {

patches/server/Reset-Ender-Crystals-on-Dragon-Spawn.patch

@@ -15,7 +15,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
 +++ b/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
 @@ -0,0 +0,0 @@ public class EndDragonFight {
-             enderDragon.moveTo(0.0D, 128.0D, 0.0D, this.level.random.nextFloat() * 360.0F, 0.0F);
+             enderDragon.moveTo((double)this.origin.getX(), (double)(128 + this.origin.getY()), (double)this.origin.getZ(), this.level.random.nextFloat() * 360.0F, 0.0F);
              this.level.addFreshEntity(enderDragon);
              this.dragonUUID = enderDragon.getUUID();
 +            this.resetSpikeCrystals(); // Paper