[ci skip] Add more identifying patch comments, merge related patches

patches/server/Add-BellRevealRaiderEvent.patch

@@ -13,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }).map((entity) -> (org.bukkit.entity.LivingEntity) entity.getBukkitEntity()).collect(java.util.stream.Collectors.toCollection(java.util.ArrayList::new)); // CraftBukkit
  
 -        org.bukkit.craftbukkit.event.CraftEventFactory.handleBellResonateEvent(world, pos, entities).forEach(BellBlockEntity::glow);
-+        org.bukkit.craftbukkit.event.CraftEventFactory.handleBellResonateEvent(world, pos, entities).forEach(entity -> glow(entity, pos)); // Paper - pass BlockPos
++        org.bukkit.craftbukkit.event.CraftEventFactory.handleBellResonateEvent(world, pos, entities).forEach(entity -> glow(entity, pos)); // Paper - Add BellRevealRaiderEvent
          // CraftBukkit end
      }
  
@@ -22,11 +22,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
 -    private static void glow(LivingEntity entity) {
-+    // Paper start
++    // Paper start - Add BellRevealRaiderEvent
 +    private static void glow(LivingEntity entity) { glow(entity, null); }
 +    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(io.papermc.paper.util.MCUtil.toLocation(entity.level(), pos)), entity.getBukkitEntity()).callEvent()) return;
-+        // Paper end
++        // Paper end - Add BellRevealRaiderEvent
          entity.addEffect(new MobEffectInstance(MobEffects.GLOWING, 60));
      }
  

patches/server/Add-BlockBreakBlockEvent.patch

@@ -12,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
  
      }
-+    // Paper start
++    // Paper start - Add BlockBreakBlockEvent
 +    public static boolean dropResources(BlockState state, LevelAccessor world, BlockPos pos, @Nullable BlockEntity blockEntity, BlockPos source) {
 +        if (world instanceof ServerLevel) {
 +            List<org.bukkit.inventory.ItemStack> items = com.google.common.collect.Lists.newArrayList();
@@ -28,7 +28,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        }
 +        return true;
 +    }
-+    // Paper end
++    // Paper end - Add BlockBreakBlockEvent
  
      public static void dropResources(BlockState state, Level world, BlockPos pos, @Nullable BlockEntity blockEntity, @Nullable Entity entity, ItemStack tool) {
          if (world instanceof ServerLevel) {
@@ -41,7 +41,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  BlockEntity tileentity = iblockdata1.hasBlockEntity() ? world.getBlockEntity(blockposition3) : null;
  
 -                dropResources(iblockdata1, world, blockposition3, tileentity);
-+                dropResources(iblockdata1, world, blockposition3, tileentity, pos); // Paper
++                dropResources(iblockdata1, world, blockposition3, tileentity, pos); // Paper - Add BlockBreakBlockEvent
                  world.setBlock(blockposition3, Blocks.AIR.defaultBlockState(), 18);
                  world.gameEvent(GameEvent.BLOCK_DESTROY, blockposition3, GameEvent.Context.of(iblockdata1));
                  if (!iblockdata1.is(BlockTags.FIRE)) {
@@ -54,7 +54,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          } else {
              if (!state.isAir()) {
 -                this.beforeDestroyingBlock(world, pos, state);
-+                this.beforeDestroyingBlock(world, pos, state, pos.relative(direction.getOpposite())); // Paper
++                this.beforeDestroyingBlock(world, pos, state, pos.relative(direction.getOpposite())); // Paper - Add BlockBreakBlockEvent
              }
  
              world.setBlock(pos, fluidState.createLegacyBlock(), 3);
@@ -62,7 +62,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      }
  
-+    protected void beforeDestroyingBlock(LevelAccessor world, BlockPos pos, BlockState state, BlockPos source) { beforeDestroyingBlock(world, pos, state); } // Paper - add source parameter
++    protected void beforeDestroyingBlock(LevelAccessor world, BlockPos pos, BlockState state, BlockPos source) { beforeDestroyingBlock(world, pos, state); } // Paper - Add BlockBreakBlockEvent
      protected abstract void beforeDestroyingBlock(LevelAccessor world, BlockPos pos, BlockState state);
  
      private static short getCacheKey(BlockPos from, BlockPos to) {
@@ -74,13 +74,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          return world.getGameRules().getBoolean(GameRules.RULE_WATER_SOURCE_CONVERSION);
      }
  
-+    // Paper start
++    // Paper start - Add BlockBreakBlockEvent
 +    @Override
 +    protected void beforeDestroyingBlock(LevelAccessor world, BlockPos pos, BlockState state,  BlockPos source) {
 +        BlockEntity tileentity = state.hasBlockEntity() ? world.getBlockEntity(pos) : null;
 +        Block.dropResources(state, world, pos, tileentity, source);
 +    }
-+    // Paper end
++    // Paper end - Add BlockBreakBlockEvent
      @Override
      protected void beforeDestroyingBlock(LevelAccessor world, BlockPos pos, BlockState state) {
          BlockEntity blockEntity = state.hasBlockEntity() ? world.getBlockEntity(pos) : null;

patches/server/Add-ElderGuardianAppearanceEvent.patch

@@ -12,24 +12,24 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public static List<ServerPlayer> addEffectToPlayersAround(ServerLevel worldserver, @Nullable Entity entity, Vec3 vec3d, double d0, MobEffectInstance mobeffect, int i, org.bukkit.event.entity.EntityPotionEffectEvent.Cause cause) {
-+        // Paper start
++        // Paper start - Add ElderGuardianAppearanceEvent
 +        return addEffectToPlayersAround(worldserver, entity, vec3d, d0, mobeffect, i, cause, null);
 +    }
 +
 +    public static List<ServerPlayer> addEffectToPlayersAround(ServerLevel worldserver, @Nullable Entity entity, Vec3 vec3d, double d0, MobEffectInstance mobeffect, int i, org.bukkit.event.entity.EntityPotionEffectEvent.Cause cause, @Nullable java.util.function.Predicate<ServerPlayer> playerPredicate) {
-+        // Paper end
++        // Paper end - Add ElderGuardianAppearanceEvent
          // CraftBukkit end
          MobEffect mobeffectlist = mobeffect.getEffect();
          List<ServerPlayer> list = worldserver.getPlayers((entityplayer) -> {
 -            return entityplayer.gameMode.isSurvival() && (entity == null || !entity.isAlliedTo((Entity) entityplayer)) && vec3d.closerThan(entityplayer.position(), d0) && (!entityplayer.hasEffect(mobeffectlist) || entityplayer.getEffect(mobeffectlist).getAmplifier() < mobeffect.getAmplifier() || entityplayer.getEffect(mobeffectlist).endsWithin(i - 1));
-+            // Paper start
++            // Paper start - Add ElderGuardianAppearanceEvent
 +            boolean condition = entityplayer.gameMode.isSurvival() && (entity == null || !entity.isAlliedTo((Entity) entityplayer)) && vec3d.closerThan(entityplayer.position(), d0) && (!entityplayer.hasEffect(mobeffectlist) || entityplayer.getEffect(mobeffectlist).getAmplifier() < mobeffect.getAmplifier() || entityplayer.getEffect(mobeffectlist).endsWithin(i - 1));
 +            if (condition) {
 +                return playerPredicate == null || playerPredicate.test(entityplayer); // Only test the player AFTER it is true
 +            } else {
 +                return false;
 +            }
-+            // Paper ned
++            // Paper ned - Add ElderGuardianAppearanceEvent
          });
  
          list.forEach((entityplayer) -> {
@@ -42,7 +42,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if ((this.tickCount + this.getId()) % 1200 == 0) {
              MobEffectInstance mobeffect = new MobEffectInstance(MobEffects.DIG_SLOWDOWN, 6000, 2);
 -            List<ServerPlayer> list = MobEffectUtil.addEffectToPlayersAround((ServerLevel) this.level(), this, this.position(), 50.0D, mobeffect, 1200, org.bukkit.event.entity.EntityPotionEffectEvent.Cause.ATTACK); // CraftBukkit
-+            List<ServerPlayer> list = MobEffectUtil.addEffectToPlayersAround((ServerLevel) this.level(), this, this.position(), 50.0D, mobeffect, 1200, org.bukkit.event.entity.EntityPotionEffectEvent.Cause.ATTACK, (player) -> new io.papermc.paper.event.entity.ElderGuardianAppearanceEvent(getBukkitEntity(), player.getBukkitEntity()).callEvent()); // CraftBukkit // Paper
++            List<ServerPlayer> list = MobEffectUtil.addEffectToPlayersAround((ServerLevel) this.level(), this, this.position(), 50.0D, mobeffect, 1200, org.bukkit.event.entity.EntityPotionEffectEvent.Cause.ATTACK, (player) -> new io.papermc.paper.event.entity.ElderGuardianAppearanceEvent(getBukkitEntity(), player.getBukkitEntity()).callEvent()); // CraftBukkit // Paper - Add ElderGuardianAppearanceEvent
  
              list.forEach((entityplayer) -> {
                  entityplayer.connection.send(new ClientboundGameEventPacket(ClientboundGameEventPacket.GUARDIAN_ELDER_EFFECT, this.isSilent() ? 0.0F : 1.0F));

patches/server/Add-EntityDamageItemEvent.patch

@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Jake Potrebic <jake.m.potrebic@gmail.com>
 Date: Tue, 22 Dec 2020 13:52:48 -0800
-Subject: [PATCH] Added EntityDamageItemEvent
+Subject: [PATCH] Add EntityDamageItemEvent
 
 
 diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
@@ -13,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
 -    public boolean hurt(int amount, RandomSource random, @Nullable ServerPlayer player) {
-+    public boolean hurt(int amount, RandomSource random, @Nullable LivingEntity player) { // Paper - allow any living entity instead of only ServerPlayers
++    public boolean hurt(int amount, RandomSource random, @Nullable LivingEntity player) { // Paper - Add EntityDamageItemEvent
          if (!this.isDamageableItem()) {
              return false;
          } else {
@@ -23,8 +23,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  // CraftBukkit start
 -                if (player != null) {
 -                    PlayerItemDamageEvent event = new PlayerItemDamageEvent(player.getBukkitEntity(), CraftItemStack.asCraftMirror(this), amount);
-+                if (player instanceof ServerPlayer serverPlayer) { // Paper
-+                    PlayerItemDamageEvent event = new PlayerItemDamageEvent(serverPlayer.getBukkitEntity(), CraftItemStack.asCraftMirror(this), amount); // Paper
++                if (player instanceof ServerPlayer serverPlayer) { // Paper - Add EntityDamageItemEvent
++                    PlayerItemDamageEvent event = new PlayerItemDamageEvent(serverPlayer.getBukkitEntity(), CraftItemStack.asCraftMirror(this), amount); // Paper - Add EntityDamageItemEvent
                      event.getPlayer().getServer().getPluginManager().callEvent(event);
  
                      if (amount != event.getDamage() || event.isCancelled()) {
@@ -32,14 +32,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      }
  
                      amount = event.getDamage();
-+                    // Paper start - EntityDamageItemEvent
++                    // Paper start - Add EntityDamageItemEvent
 +                } else if (player != null) {
 +                    io.papermc.paper.event.entity.EntityDamageItemEvent event = new io.papermc.paper.event.entity.EntityDamageItemEvent(player.getBukkitLivingEntity(), CraftItemStack.asCraftMirror(this), amount);
 +                    if (!event.callEvent()) {
 +                        return false;
 +                    }
 +                    amount = event.getDamage();
-+                    // Paper end
++                    // Paper end - Add EntityDamageItemEvent
                  }
                  // CraftBukkit end
                  if (amount <= 0) {
@@ -49,8 +49,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 -            if (player != null && amount != 0) {
 -                CriteriaTriggers.ITEM_DURABILITY_CHANGED.trigger(player, this, this.getDamageValue() + amount);
-+            if (player instanceof ServerPlayer serverPlayer && amount != 0) { // Paper
-+                CriteriaTriggers.ITEM_DURABILITY_CHANGED.trigger(serverPlayer, this, this.getDamageValue() + amount); // Paper
++            if (player instanceof ServerPlayer serverPlayer && amount != 0) { // Paper - Add EntityDamageItemEvent
++                CriteriaTriggers.ITEM_DURABILITY_CHANGED.trigger(serverPlayer, this, this.getDamageValue() + amount); // Paper - Add EntityDamageItemEvent
              }
  
              j = this.getDamageValue() + amount;
@@ -59,7 +59,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (!entity.level().isClientSide && (!(entity instanceof net.minecraft.world.entity.player.Player) || !((net.minecraft.world.entity.player.Player) entity).getAbilities().instabuild)) {
              if (this.isDamageableItem()) {
 -                if (this.hurt(amount, entity.getRandom(), entity instanceof ServerPlayer ? (ServerPlayer) entity : null)) {
-+                if (this.hurt(amount, entity.getRandom(), entity /*instanceof ServerPlayer ? (ServerPlayer) entity : null*/)) { // Paper - pass LivingEntity for EntityItemDamageEvent
++                if (this.hurt(amount, entity.getRandom(), entity /*instanceof ServerPlayer ? (ServerPlayer) entity : null*/)) { // Paper - Add EntityDamageItemEvent
                      breakCallback.accept(entity);
                      Item item = this.getItem();
                      // CraftBukkit start - Check for item breaking

patches/server/Add-EntityInsideBlockEvent.patch

@@ -12,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (!entity.fireImmune()) {
              entity.setRemainingFireTicks(entity.getRemainingFireTicks() + 1);
              if (entity.getRemainingFireTicks() == 0) {
@@ -24,7 +24,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (!world.isClientSide) {
              int i = this.getSignalForState(state);
  
@@ -36,7 +36,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (!world.isClientSide) {
              if (state.getValue(BigDripleafBlock.TILT) == Tilt.NONE && BigDripleafBlock.canEntityTilt(pos, entity) && !world.hasNeighborSignal(pos)) {
                  // CraftBukkit start - tilt dripleaf
@@ -48,7 +48,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          BlockState blockState = world.getBlockState(pos.above());
          if (blockState.isAir()) {
              entity.onAboveBubbleCol(state.getValue(DRAG_DOWN));
@@ -60,7 +60,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (!world.isClientSide && this.type.canButtonBeActivatedByArrows() && !(Boolean) state.getValue(ButtonBlock.POWERED)) {
              this.checkPressed(state, world, pos);
          }
@@ -72,7 +72,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          CraftEventFactory.blockDamage = world.getWorld().getBlockAt(pos.getX(), pos.getY(), pos.getZ()); // CraftBukkit
          entity.hurt(world.damageSources().cactus(), 1.0F);
          CraftEventFactory.blockDamage = null; // CraftBukkit
@@ -84,7 +84,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if ((Boolean) state.getValue(CampfireBlock.LIT) && entity instanceof LivingEntity && !EnchantmentHelper.hasFrostWalker((LivingEntity) entity)) {
              org.bukkit.craftbukkit.event.CraftEventFactory.blockDamage = CraftBlock.at(world, pos); // CraftBukkit
              entity.hurt(world.damageSources().inFire(), (float) this.fireDamage);
@@ -96,7 +96,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (entity instanceof Ravager && CraftEventFactory.callEntityChangeBlockEvent(entity, pos, Blocks.AIR.defaultBlockState(), !world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING))) { // CraftBukkit
              world.destroyBlock(pos, true, entity);
          }
@@ -108,7 +108,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (!world.isClientSide) {
              if (!(Boolean) state.getValue(DetectorRailBlock.POWERED)) {
                  this.checkPressed(world, pos, state);
@@ -120,7 +120,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (world instanceof ServerLevel && entity.canChangeDimensions() && Shapes.joinIsNotEmpty(Shapes.create(entity.getBoundingBox().move((double) (-pos.getX()), (double) (-pos.getY()), (double) (-pos.getZ()))), state.getShape(world, pos), BooleanOp.AND)) {
              ResourceKey<Level> resourcekey = world.getTypeKey() == LevelStem.END ? Level.OVERWORLD : Level.END; // CraftBukkit - SPIGOT-6152: send back to main overworld in custom ends
              ServerLevel worldserver = ((ServerLevel) world).getServer().getLevel(resourcekey);
@@ -132,7 +132,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (entity.getType().equals(EntityType.FALLING_BLOCK)) {
              this.destroyBlock(world, pos);
          }
@@ -144,7 +144,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (this.isSlidingDown(pos, entity)) {
              this.maybeDoSlideAchievement(entity, pos);
              this.doSlideMovement(entity);
@@ -156,7 +156,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          BlockEntity blockEntity = world.getBlockEntity(pos);
          if (blockEntity instanceof HopperBlockEntity) {
              HopperBlockEntity.entityInside(world, pos, state, entity, (HopperBlockEntity)blockEntity);
@@ -168,7 +168,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (this.isEntityInsideContent(state, pos, entity)) {
              entity.lavaHurt();
          }
@@ -180,7 +180,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (!world.isClientSide && entity.isOnFire() && this.isEntityInsideContent(state, pos, entity)) {
              // CraftBukkit start
              if (entity.mayInteract(world, pos)) {
@@ -192,7 +192,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (entity.canChangeDimensions()) {
              // CraftBukkit start - Entity in portal
              EntityPortalEnterEvent event = new EntityPortalEnterEvent(entity.getBukkitEntity(), new org.bukkit.Location(world.getWorld(), pos.getX(), pos.getY(), pos.getZ()));
@@ -204,7 +204,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (entity instanceof Ravager && world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
              world.destroyBlock(pos, true, entity);
          }
@@ -216,7 +216,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (!(entity instanceof LivingEntity) || entity.getFeetBlockState().is((Block) this)) {
              entity.makeStuckInBlock(state, new Vec3(0.8999999761581421D, 1.5D, 0.8999999761581421D));
              if (world.isClientSide) {
@@ -228,7 +228,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (entity instanceof LivingEntity && entity.getType() != EntityType.FOX && entity.getType() != EntityType.BEE) {
              entity.makeStuckInBlock(state, new Vec3(0.800000011920929D, 0.75D, 0.800000011920929D));
              if (!world.isClientSide && (Integer) state.getValue(SweetBerryBushBlock.AGE) > 0 && (entity.xOld != entity.getX() || entity.zOld != entity.getZ())) {
@@ -240,7 +240,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (!world.isClientSide) {
              if (!(Boolean) state.getValue(TripWireBlock.POWERED)) {
                  this.checkPressed(world, pos);
@@ -252,7 +252,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
          super.entityInside(state, world, pos, entity);
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (world instanceof ServerLevel && entity instanceof Boat) {
              // CraftBukkit start
              if (!CraftEventFactory.callEntityChangeBlockEvent(entity, pos, Blocks.AIR.defaultBlockState())) {
@@ -264,7 +264,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          entity.makeStuckInBlock(state, new Vec3(0.25D, (double)0.05F, 0.25D));
      }
  }
@@ -276,7 +276,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (!world.isClientSide && world.getDifficulty() != Difficulty.PEACEFUL) {
              if (entity instanceof LivingEntity) {
                  LivingEntity entityliving = (LivingEntity) entity;

patches/server/Add-PlayerArmSwingEvent.patch

@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Jake Potrebic <jake.m.potrebic@gmail.com>
 Date: Fri, 12 Mar 2021 19:22:21 -0800
-Subject: [PATCH] Adds PlayerArmSwingEvent
+Subject: [PATCH] Add PlayerArmSwingEvent
 
 
 diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
@@ -13,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
          // Arm swing animation
 -        PlayerAnimationEvent event = new PlayerAnimationEvent(this.getCraftPlayer(), (packet.getHand() == InteractionHand.MAIN_HAND) ? PlayerAnimationType.ARM_SWING : PlayerAnimationType.OFF_ARM_SWING);
-+        io.papermc.paper.event.player.PlayerArmSwingEvent event = new io.papermc.paper.event.player.PlayerArmSwingEvent(this.getCraftPlayer(), packet.getHand() == InteractionHand.MAIN_HAND ? org.bukkit.inventory.EquipmentSlot.HAND : org.bukkit.inventory.EquipmentSlot.OFF_HAND); // Paper
++        io.papermc.paper.event.player.PlayerArmSwingEvent event = new io.papermc.paper.event.player.PlayerArmSwingEvent(this.getCraftPlayer(), packet.getHand() == InteractionHand.MAIN_HAND ? org.bukkit.inventory.EquipmentSlot.HAND : org.bukkit.inventory.EquipmentSlot.OFF_HAND); // Paper - Add PlayerArmSwingEvent
          this.cserver.getPluginManager().callEvent(event);
  
          if (event.isCancelled()) return;

patches/server/Add-PlayerKickEvent-causes.patch

@@ -33,17 +33,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public static class DecodeException extends ThrowingComponent {
          private final boolean shouldDisconnect;
-+        public final org.bukkit.event.player.PlayerKickEvent.Cause kickCause; // Paper
++        public final org.bukkit.event.player.PlayerKickEvent.Cause kickCause; // Paper - kick event causes
  
          public DecodeException(Component message, boolean shouldDisconnect) {
-+            // Paper start
++            // Paper start - kick event causes
 +            this(message, shouldDisconnect, org.bukkit.event.player.PlayerKickEvent.Cause.UNKNOWN);
 +        }
 +        public DecodeException(Component message, boolean shouldDisconnect, org.bukkit.event.player.PlayerKickEvent.Cause kickCause) {
-+            // Paper end
++            // Paper end - kick event causes
              super(message);
              this.shouldDisconnect = shouldDisconnect;
-+            this.kickCause = kickCause; // Paper
++            this.kickCause = kickCause; // Paper - kick event causes
          }
  
          public boolean shouldDisconnect() {

patches/server/Add-PlayerSetSpawnEvent.patch

@@ -12,40 +12,40 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          ResourceKey<Level> resourcekey = source.getLevel().dimension();
          Iterator iterator = targets.iterator();
  
-+        final Collection<ServerPlayer> actualTargets = new java.util.ArrayList<>(); // Paper
++        final Collection<ServerPlayer> actualTargets = new java.util.ArrayList<>(); // Paper - Add PlayerSetSpawnEvent
          while (iterator.hasNext()) {
              ServerPlayer entityplayer = (ServerPlayer) iterator.next();
  
 -            entityplayer.setRespawnPosition(resourcekey, pos, angle, true, false, org.bukkit.event.player.PlayerSpawnChangeEvent.Cause.COMMAND); // CraftBukkit
-+            // Paper start - PlayerSetSpawnEvent
++            // Paper start - Add PlayerSetSpawnEvent
 +            if (entityplayer.setRespawnPosition(resourcekey, pos, angle, true, false, com.destroystokyo.paper.event.player.PlayerSetSpawnEvent.Cause.COMMAND)) {
 +                actualTargets.add(entityplayer);
 +            }
-+            // Paper end
++            // Paper end - Add PlayerSetSpawnEvent
          }
-+        // Paper start
++        // Paper start - Add PlayerSetSpawnEvent
 +        if (actualTargets.isEmpty()) {
 +            return 0;
 +        }
-+        // Paper end
++        // Paper end - Add PlayerSetSpawnEvent
  
          String s = resourcekey.location().toString();
  
 -        if (targets.size() == 1) {
-+        if (actualTargets.size() == 1) { // Paper
++        if (actualTargets.size() == 1) { // Paper - Add PlayerSetSpawnEvent
              source.sendSuccess(() -> {
 -                return Component.translatable("commands.spawnpoint.success.single", pos.getX(), pos.getY(), pos.getZ(), angle, s, ((ServerPlayer) targets.iterator().next()).getDisplayName());
-+                return Component.translatable("commands.spawnpoint.success.single", pos.getX(), pos.getY(), pos.getZ(), angle, s, ((ServerPlayer) actualTargets.iterator().next()).getDisplayName()); // Paper
++                return Component.translatable("commands.spawnpoint.success.single", pos.getX(), pos.getY(), pos.getZ(), angle, s, ((ServerPlayer) actualTargets.iterator().next()).getDisplayName()); // Paper - Add PlayerSetSpawnEvent
              }, true);
          } else {
              source.sendSuccess(() -> {
 -                return Component.translatable("commands.spawnpoint.success.multiple", pos.getX(), pos.getY(), pos.getZ(), angle, s, targets.size());
-+                return Component.translatable("commands.spawnpoint.success.multiple", pos.getX(), pos.getY(), pos.getZ(), angle, s, actualTargets.size()); // Paper
++                return Component.translatable("commands.spawnpoint.success.multiple", pos.getX(), pos.getY(), pos.getZ(), angle, s, actualTargets.size()); // Paper - Add PlayerSetSpawnEvent
              }, true);
          }
  
 -        return targets.size();
-+        return actualTargets.size(); // Paper
++        return actualTargets.size(); // Paper - Add PlayerSetSpawnEvent
      }
  }
 diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
@@ -57,7 +57,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  return Either.left(Player.BedSleepingProblem.OBSTRUCTED);
              } else {
 -                this.setRespawnPosition(this.level().dimension(), blockposition, this.getYRot(), false, true, PlayerSpawnChangeEvent.Cause.BED); // CraftBukkit
-+                this.setRespawnPosition(this.level().dimension(), blockposition, this.getYRot(), false, true, com.destroystokyo.paper.event.player.PlayerSetSpawnEvent.Cause.BED); // Paper - PlayerSetSpawnEvent
++                this.setRespawnPosition(this.level().dimension(), blockposition, this.getYRot(), false, true, com.destroystokyo.paper.event.player.PlayerSetSpawnEvent.Cause.BED); // Paper - Add PlayerSetSpawnEvent
                  if (this.level().isDay()) {
                      return Either.left(Player.BedSleepingProblem.NOT_POSSIBLE_NOW);
                  } else {
@@ -65,7 +65,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          return this.respawnForced;
      }
  
-+    @Deprecated // Paper
++    @Deprecated // Paper - Add PlayerSetSpawnEvent
      public void setRespawnPosition(ResourceKey<Level> dimension, @Nullable BlockPos pos, float angle, boolean forced, boolean sendMessage) {
 -        // CraftBukkit start
 -        this.setRespawnPosition(dimension, pos, angle, forced, sendMessage, PlayerSpawnChangeEvent.Cause.UNKNOWN);
@@ -91,7 +91,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -            resourcekey = Level.OVERWORLD;
 -            blockposition = null;
 -            f = 0.0F;
-+        // Paper start
++        // Paper start - Add PlayerSetSpawnEvent
 +        this.setRespawnPosition(dimension, pos, angle, forced, sendMessage, com.destroystokyo.paper.event.player.PlayerSetSpawnEvent.Cause.UNKNOWN);
 +    }
 +    @Deprecated
@@ -126,12 +126,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            pos = io.papermc.paper.util.MCUtil.toBlockPosition(event.getLocation());
 +            angle = event.getLocation().getYaw();
 +            forced = event.isForced();
-+            // Paper end
++            // Paper end - Add PlayerSetSpawnEvent
  
 -            if (flag1 && !flag2) {
 -                this.sendSystemMessage(Component.translatable("block.minecraft.set_spawn"));
-+            if (event.willNotifyPlayer() && event.getNotification() != null) { // Paper
-+                this.sendSystemMessage(PaperAdventure.asVanilla(event.getNotification())); // Paper
++            if (event.willNotifyPlayer() && event.getNotification() != null) { // Paper - Add PlayerSetSpawnEvent
++                this.sendSystemMessage(PaperAdventure.asVanilla(event.getNotification())); // Paper - Add PlayerSetSpawnEvent
              }
  
 -            this.respawnPosition = blockposition;
@@ -149,7 +149,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.respawnForced = false;
          }
  
-+        return true; // Paper
++        return true; // Paper - Add PlayerSetSpawnEvent
      }
  
      public SectionPos getLastSectionPos() {
@@ -162,7 +162,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  } else if (blockposition != null) {
                      entityplayer1.connection.send(new ClientboundGameEventPacket(ClientboundGameEventPacket.NO_RESPAWN_BLOCK_AVAILABLE, 0.0F));
 -                    entityplayer1.setRespawnPosition(null, null, 0f, false, false, PlayerSpawnChangeEvent.Cause.RESET); // CraftBukkit - SPIGOT-5988: Clear respawn location when obstructed
-+                    entityplayer1.setRespawnPosition(null, null, 0f, false, false, com.destroystokyo.paper.event.player.PlayerSetSpawnEvent.Cause.PLAYER_RESPAWN); // CraftBukkit - SPIGOT-5988: Clear respawn location when obstructed // Paper - PlayerSetSpawnEvent
++                    entityplayer1.setRespawnPosition(null, null, 0f, false, false, com.destroystokyo.paper.event.player.PlayerSetSpawnEvent.Cause.PLAYER_RESPAWN); // CraftBukkit - SPIGOT-5988: Clear respawn location when obstructed // Paper - Add PlayerSetSpawnEvent
                  }
              }
  
@@ -175,14 +175,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
                  if (entityplayer.getRespawnDimension() != world.dimension() || !pos.equals(entityplayer.getRespawnPosition())) {
 -                    entityplayer.setRespawnPosition(world.dimension(), pos, 0.0F, false, true, org.bukkit.event.player.PlayerSpawnChangeEvent.Cause.RESPAWN_ANCHOR); // CraftBukkit
-+                    if (entityplayer.setRespawnPosition(world.dimension(), pos, 0.0F, false, true, com.destroystokyo.paper.event.player.PlayerSetSpawnEvent.Cause.RESPAWN_ANCHOR)) { // Paper - PlayerSetSpawnEvent
++                    if (entityplayer.setRespawnPosition(world.dimension(), pos, 0.0F, false, true, com.destroystokyo.paper.event.player.PlayerSetSpawnEvent.Cause.RESPAWN_ANCHOR)) { // Paper - Add PlayerSetSpawnEvent
                      world.playSound((Player) null, (double) pos.getX() + 0.5D, (double) pos.getY() + 0.5D, (double) pos.getZ() + 0.5D, SoundEvents.RESPAWN_ANCHOR_SET_SPAWN, SoundSource.BLOCKS, 1.0F, 1.0F);
                      return InteractionResult.SUCCESS;
-+                    // Paper start - handle failed set spawn
++                    // Paper start - Add PlayerSetSpawnEvent
 +                    } else {
 +                        return InteractionResult.FAIL;
 +                    }
-+                    // Paper end
++                    // Paper end - Add PlayerSetSpawnEvent
                  }
              }
  
@@ -195,10 +195,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public void setBedSpawnLocation(Location location, boolean override) {
          if (location == null) {
 -            this.getHandle().setRespawnPosition(null, null, 0.0F, override, false, PlayerSpawnChangeEvent.Cause.PLUGIN);
-+            this.getHandle().setRespawnPosition(null, null, 0.0F, override, false, com.destroystokyo.paper.event.player.PlayerSetSpawnEvent.Cause.PLUGIN); // Paper - PlayerSetSpawnEvent
++            this.getHandle().setRespawnPosition(null, null, 0.0F, override, false, com.destroystokyo.paper.event.player.PlayerSetSpawnEvent.Cause.PLUGIN); // Paper - Add PlayerSetSpawnEvent
          } else {
 -            this.getHandle().setRespawnPosition(((CraftWorld) location.getWorld()).getHandle().dimension(), CraftLocation.toBlockPosition(location), location.getYaw(), override, false, PlayerSpawnChangeEvent.Cause.PLUGIN);
-+            this.getHandle().setRespawnPosition(((CraftWorld) location.getWorld()).getHandle().dimension(), CraftLocation.toBlockPosition(location), location.getYaw(), override, false, com.destroystokyo.paper.event.player.PlayerSetSpawnEvent.Cause.PLUGIN); // Paper - PlayerSetSpawnEvent
++            this.getHandle().setRespawnPosition(((CraftWorld) location.getWorld()).getHandle().dimension(), CraftLocation.toBlockPosition(location), location.getYaw(), override, false, com.destroystokyo.paper.event.player.PlayerSetSpawnEvent.Cause.PLUGIN); // Paper - Add PlayerSetSpawnEvent
          }
      }
  

patches/server/Add-Unix-domain-socket-support.patch

@@ -3,12 +3,6 @@ From: Andrew Steinborn <git@steinborn.me>
 Date: Tue, 11 May 2021 17:39:22 -0400
 Subject: [PATCH] Add Unix domain socket support
 
-For Windows and ARM support, JEP-380 is required:
-https://inside.java/2021/02/03/jep380-unix-domain-sockets-channels/
-This will be possible as of the Minecraft 1.17 Java version bump.
-
-Tested-by: Mariell Hoversholm <proximyst@proximyst.com>
-Reviewed-by: Mariell Hoversholm <proximyst@proximyst.com>
 
 diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
@@ -41,7 +35,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
 +        bindAddress = new java.net.InetSocketAddress(inetaddress, this.getPort());
 +        }
-+        // Paper end
++        // Paper end - Unix domain socket support
  
          this.initializeKeyPair();
          DedicatedServer.LOGGER.info("Starting Minecraft server on {}:{}", this.getLocalIp().isEmpty() ? "*" : this.getLocalIp(), this.getPort());
@@ -60,12 +54,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          this.running = true;
      }
  
-+    // Paper start
++    // Paper start - Unix domain socket support
      public void startTcpServerListener(@Nullable InetAddress address, int port) throws IOException {
 +        bind(new java.net.InetSocketAddress(address, port));
 +    }
 +    public void bind(java.net.SocketAddress address) throws IOException {
-+    // Paper end
++    // Paper end - Unix domain socket support
          List list = this.channels;
  
          synchronized (this.channels) {
@@ -73,13 +67,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              EventLoopGroup eventloopgroup;
  
              if (Epoll.isAvailable() && this.server.isEpollEnabled()) {
-+                // Paper start
++                // Paper start - Unix domain socket support
 +                if (address instanceof io.netty.channel.unix.DomainSocketAddress) {
 +                    oclass = io.netty.channel.epoll.EpollServerDomainSocketChannel.class;
 +                } else {
                  oclass = EpollServerSocketChannel.class;
 +                }
-+                // Paper end
++                // Paper end - Unix domain socket support
                  eventloopgroup = (EventLoopGroup) ServerConnectionListener.SERVER_EPOLL_EVENT_GROUP.get();
                  ServerConnectionListener.LOGGER.info("Using epoll channel type");
              } else {
@@ -88,7 +82,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      io.papermc.paper.network.ChannelInitializeListenerHolder.callListeners(channel); // Paper
                  }
 -            }).group(eventloopgroup).localAddress(address, port)).option(ChannelOption.AUTO_READ, false).bind().syncUninterruptibly()); // CraftBukkit
-+            }).group(eventloopgroup).localAddress(address)).option(ChannelOption.AUTO_READ, false).bind().syncUninterruptibly()); // CraftBukkit // Paper
++            }).group(eventloopgroup).localAddress(address)).option(ChannelOption.AUTO_READ, false).bind().syncUninterruptibly()); // CraftBukkit // Paper - Unix domain socket support
          }
      }
  
@@ -100,11 +94,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      // Spigot Start
      public SocketAddress getRawAddress()
      {
-+        // Paper start - this can be nullable in the case of a Unix domain socket, so if it is, fake something
++        // Paper start - Unix domain socket support; this can be nullable in the case of a Unix domain socket, so if it is, fake something
 +        if (connection.channel.remoteAddress() == null) {
 +            return new java.net.InetSocketAddress(java.net.InetAddress.getLoopbackAddress(), 0);
 +        }
-+        // Paper end
++        // Paper end - Unix domain socket support
          return this.connection.channel.remoteAddress();
      }
      // Spigot End
@@ -116,7 +110,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  this.connection.setClientboundProtocolAfterHandshake(ClientIntent.LOGIN);
                  // CraftBukkit start - Connection throttle
                  try {
-+                    if (!(this.connection.channel.localAddress() instanceof io.netty.channel.unix.DomainSocketAddress)) { // Paper - the connection throttle is useless when you have a Unix domain socket
++                    if (!(this.connection.channel.localAddress() instanceof io.netty.channel.unix.DomainSocketAddress)) { // Paper - Unix domain socket support; the connection throttle is useless when you have a Unix domain socket
                      long currentTime = System.currentTimeMillis();
                      long connectionThrottle = this.server.server.getConnectionThrottle();
                      InetAddress address = ((java.net.InetSocketAddress) this.connection.getRemoteAddress()).getAddress();
@@ -124,7 +118,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                              }
                          }
                      }
-+                    } // Paper - add closing bracket for if check above
++                    } // Paper - Unix domain socket support
                  } catch (Throwable t) {
                      org.apache.logging.log4j.LogManager.getLogger().debug("Failed to check connection throttle", t);
                  }
@@ -137,7 +131,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                              this.connection.hostname = split[0];
 -                            this.connection.address = new java.net.InetSocketAddress(split[1], ((java.net.InetSocketAddress) this.connection.getRemoteAddress()).getPort());
 +                            this.connection.address = new java.net.InetSocketAddress(split[1], socketAddress instanceof java.net.InetSocketAddress ? ((java.net.InetSocketAddress) socketAddress).getPort() : 0);
-+                            // Paper end
++                            // Paper end - Unix domain socket support
                              this.connection.spoofedUUID = com.mojang.util.UndashedUuid.fromStringLenient( split[2] );
                          } else
                          {

patches/server/Add-cause-to-Weather-ThunderChangeEvents.patch

@@ -14,8 +14,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          this.serverLevelData.setThunderTime(rainDuration);
 -        this.serverLevelData.setRaining(raining);
 -        this.serverLevelData.setThundering(thundering);
-+        this.serverLevelData.setRaining(raining, org.bukkit.event.weather.WeatherChangeEvent.Cause.COMMAND); // Paper
-+        this.serverLevelData.setThundering(thundering, org.bukkit.event.weather.ThunderChangeEvent.Cause.COMMAND); // Paper
++        this.serverLevelData.setRaining(raining, org.bukkit.event.weather.WeatherChangeEvent.Cause.COMMAND); // Paper - Add cause to Weather/ThunderChangeEvents
++        this.serverLevelData.setThundering(thundering, org.bukkit.event.weather.ThunderChangeEvent.Cause.COMMAND); // Paper - Add cause to Weather/ThunderChangeEvents
      }
  
      @Override
@@ -25,8 +25,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  this.serverLevelData.setClearWeatherTime(i);
 -                this.serverLevelData.setThundering(flag1);
 -                this.serverLevelData.setRaining(flag2);
-+                this.serverLevelData.setThundering(flag1, org.bukkit.event.weather.ThunderChangeEvent.Cause.NATURAL); // Paper
-+                this.serverLevelData.setRaining(flag2, org.bukkit.event.weather.WeatherChangeEvent.Cause.NATURAL); // Paper
++                this.serverLevelData.setThundering(flag1, org.bukkit.event.weather.ThunderChangeEvent.Cause.NATURAL); // Paper - Add cause to Weather/ThunderChangeEvents
++                this.serverLevelData.setRaining(flag2, org.bukkit.event.weather.WeatherChangeEvent.Cause.NATURAL); // Paper - Add cause to Weather/ThunderChangeEvents
              }
  
              this.oThunderLevel = this.thunderLevel;
@@ -35,7 +35,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public void resetWeatherCycle() {
          // CraftBukkit start
 -        this.serverLevelData.setRaining(false);
-+        this.serverLevelData.setRaining(false, org.bukkit.event.weather.WeatherChangeEvent.Cause.SLEEP); // Paper - when passing the night
++        this.serverLevelData.setRaining(false, org.bukkit.event.weather.WeatherChangeEvent.Cause.SLEEP); // Paper - Add cause to Weather/ThunderChangeEvents
          // If we stop due to everyone sleeping we should reset the weather duration to some other random value.
          // Not that everyone ever manages to get the whole server to sleep at the same time....
          if (!this.serverLevelData.isRaining()) {
@@ -43,7 +43,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
          // CraftBukkit end
 -        this.serverLevelData.setThundering(false);
-+        this.serverLevelData.setThundering(false, org.bukkit.event.weather.ThunderChangeEvent.Cause.SLEEP); // Paper - when passing the night
++        this.serverLevelData.setThundering(false, org.bukkit.event.weather.ThunderChangeEvent.Cause.SLEEP); // Paper - Add cause to Weather/ThunderChangeEvents
          // CraftBukkit start
          // If we stop due to everyone sleeping we should reset the weather duration to some other random value.
          // Not that everyone ever manages to get the whole server to sleep at the same time....
@@ -55,11 +55,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void setThundering(boolean thundering) {
-+        // Paper start
++        // Paper start - Add cause to Weather/ThunderChangeEvents
 +        this.setThundering(thundering, org.bukkit.event.weather.ThunderChangeEvent.Cause.UNKNOWN);
 +    }
 +    public void setThundering(boolean thundering, org.bukkit.event.weather.ThunderChangeEvent.Cause cause) {
-+        // Paper end
++        // Paper end - Add cause to Weather/ThunderChangeEvents
          // CraftBukkit start
          if (this.thundering == thundering) {
              return;
@@ -68,7 +68,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          org.bukkit.World world = Bukkit.getWorld(this.getLevelName());
          if (world != null) {
 -            ThunderChangeEvent thunder = new ThunderChangeEvent(world, thundering);
-+            ThunderChangeEvent thunder = new ThunderChangeEvent(world, thundering, cause); // Paper
++            ThunderChangeEvent thunder = new ThunderChangeEvent(world, thundering, cause); // Paper - Add cause to Weather/ThunderChangeEvents
              Bukkit.getServer().getPluginManager().callEvent(thunder);
              if (thunder.isCancelled()) {
                  return;
@@ -76,12 +76,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void setRaining(boolean raining) {
-+        // Paper start
++        // Paper start - Add cause to Weather/ThunderChangeEvents
 +        this.setRaining(raining, org.bukkit.event.weather.WeatherChangeEvent.Cause.UNKNOWN);
 +    }
 +
 +    public void setRaining(boolean raining, org.bukkit.event.weather.WeatherChangeEvent.Cause cause) {
-+        // Paper end
++        // Paper end - Add cause to Weather/ThunderChangeEvents
          // CraftBukkit start
          if (this.raining == raining) {
              return;
@@ -90,7 +90,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          org.bukkit.World world = Bukkit.getWorld(this.getLevelName());
          if (world != null) {
 -            WeatherChangeEvent weather = new WeatherChangeEvent(world, raining);
-+            WeatherChangeEvent weather = new WeatherChangeEvent(world, raining, cause); // Paper
++            WeatherChangeEvent weather = new WeatherChangeEvent(world, raining, cause); // Paper - Add cause to Weather/ThunderChangeEvents
              Bukkit.getServer().getPluginManager().callEvent(weather);
              if (weather.isCancelled()) {
                  return;
@@ -103,7 +103,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public void setStorm(boolean hasStorm) {
 -        this.world.levelData.setRaining(hasStorm);
-+        this.world.serverLevelData.setRaining(hasStorm, org.bukkit.event.weather.WeatherChangeEvent.Cause.PLUGIN); // Paper
++        this.world.serverLevelData.setRaining(hasStorm, org.bukkit.event.weather.WeatherChangeEvent.Cause.PLUGIN); // Paper - Add cause to Weather/ThunderChangeEvents
          this.setWeatherDuration(0); // Reset weather duration (legacy behaviour)
          this.setClearWeatherDuration(0); // Reset clear weather duration (reset "/weather clear" commands)
      }
@@ -112,7 +112,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public void setThundering(boolean thundering) {
 -        this.world.serverLevelData.setThundering(thundering);
-+        this.world.serverLevelData.setThundering(thundering, org.bukkit.event.weather.ThunderChangeEvent.Cause.PLUGIN); // Paper
++        this.world.serverLevelData.setThundering(thundering, org.bukkit.event.weather.ThunderChangeEvent.Cause.PLUGIN); // Paper - Add cause to Weather/ThunderChangeEvents
          this.setThunderDuration(0); // Reset weather duration (legacy behaviour)
          this.setClearWeatherDuration(0); // Reset clear weather duration (reset "/weather clear" commands)
      }

patches/server/Add-config-for-mobs-immune-to-default-effects.patch

@@ -13,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              MobEffect mobeffectlist = effect.getEffect();
  
 -            if (mobeffectlist == MobEffects.REGENERATION || mobeffectlist == MobEffects.POISON) {
-+            if ((mobeffectlist == MobEffects.REGENERATION || mobeffectlist == MobEffects.POISON) && this.level().paperConfig().entities.mobEffects.undeadImmuneToCertainEffects) { // Paper
++            if ((mobeffectlist == MobEffects.REGENERATION || mobeffectlist == MobEffects.POISON) && this.level().paperConfig().entities.mobEffects.undeadImmuneToCertainEffects) { // Paper - Add config for mobs immune to default effects
                  return false;
              }
          }
@@ -26,7 +26,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public boolean canBeAffected(MobEffectInstance effect) {
 -        return effect.getEffect() == MobEffects.WITHER ? false : super.canBeAffected(effect);
-+        return effect.getEffect() == MobEffects.WITHER && this.level().paperConfig().entities.mobEffects.immuneToWitherEffect.wither ? false : super.canBeAffected(effect); // Paper
++        return effect.getEffect() == MobEffects.WITHER && this.level().paperConfig().entities.mobEffects.immuneToWitherEffect.wither ? false : super.canBeAffected(effect); // Paper - Add config for mobs immune to default effects
      }
  
      private class WitherDoNothingGoal extends Goal {
@@ -39,7 +39,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public boolean canBeAffected(MobEffectInstance effect) {
 -        return effect.getEffect() == MobEffects.POISON ? false : super.canBeAffected(effect);
-+        return effect.getEffect() == MobEffects.POISON && this.level().paperConfig().entities.mobEffects.spidersImmuneToPoisonEffect ? false : super.canBeAffected(effect); // Paper
++        return effect.getEffect() == MobEffects.POISON && this.level().paperConfig().entities.mobEffects.spidersImmuneToPoisonEffect ? false : super.canBeAffected(effect); // Paper - Add config for mobs immune to default effects
      }
  
      public boolean isClimbing() {
@@ -52,6 +52,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public boolean canBeAffected(MobEffectInstance effect) {
 -        return effect.getEffect() == MobEffects.WITHER ? false : super.canBeAffected(effect);
-+        return effect.getEffect() == MobEffects.WITHER && this.level().paperConfig().entities.mobEffects.immuneToWitherEffect.witherSkeleton ? false : super.canBeAffected(effect); // Paper
++        return effect.getEffect() == MobEffects.WITHER && this.level().paperConfig().entities.mobEffects.immuneToWitherEffect.witherSkeleton ? false : super.canBeAffected(effect); // Paper - Add config for mobs immune to default effects
      }
  }

patches/server/Add-missing-forceDrop-toggles.patch

@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Jake Potrebic <jake.m.potrebic@gmail.com>
 Date: Tue, 20 Jul 2021 21:25:35 -0700
-Subject: [PATCH] Add a bunch of missing forceDrop toggles
+Subject: [PATCH] Add missing forceDrop toggles
 
 
 diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/WorkAtComposter.java b/src/main/java/net/minecraft/world/entity/ai/behavior/WorkAtComposter.java
@@ -12,9 +12,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  simpleContainer.removeItemType(Items.WHEAT, m);
                  ItemStack itemStack = simpleContainer.addItem(new ItemStack(Items.BREAD, l));
                  if (!itemStack.isEmpty()) {
-+                    entity.forceDrops = true; // Paper
++                    entity.forceDrops = true; // Paper - Add missing forceDrop toggles
                      entity.spawnAtLocation(itemStack, 0.5F);
-+                    entity.forceDrops = false; // Paper
++                    entity.forceDrops = false; // Paper - Add missing forceDrop toggles
                  }
  
              }
@@ -26,9 +26,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
  
          if (!this.level().isClientSide() && this.random.nextInt(700) == 0 && this.level().getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
-+            this.forceDrops = true; // Paper
++            this.forceDrops = true; // Paper - Add missing forceDrop toggles
              this.spawnAtLocation((ItemLike) Items.SLIME_BALL);
-+            this.forceDrops = false; // Paper
++            this.forceDrops = false; // Paper - Add missing forceDrop toggles
          }
  
      }
@@ -36,9 +36,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  ItemStack itemstack1 = this.getItemBySlot(EquipmentSlot.MAINHAND);
  
                  if (!itemstack1.isEmpty() && !player.getAbilities().instabuild) {
-+                    this.forceDrops = true; // Paper
++                    this.forceDrops = true; // Paper - Add missing forceDrop toggles
                      this.spawnAtLocation(itemstack1);
-+                    this.forceDrops = false; // Paper
++                    this.forceDrops = false; // Paper - Add missing forceDrop toggles
                  }
  
                  this.setItemSlot(EquipmentSlot.MAINHAND, new ItemStack(itemstack.getItem(), 1));
@@ -46,9 +46,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              ItemStack itemstack = Panda.this.getItemBySlot(EquipmentSlot.MAINHAND);
  
              if (!itemstack.isEmpty()) {
-+                Panda.this.forceDrops = true; // Paper
++                Panda.this.forceDrops = true; // Paper - Add missing forceDrop toggles
                  Panda.this.spawnAtLocation(itemstack);
-+                Panda.this.forceDrops = false; // Paper
++                Panda.this.forceDrops = false; // Paper - Add missing forceDrop toggles
                  Panda.this.setItemSlot(EquipmentSlot.MAINHAND, ItemStack.EMPTY);
                  int i = Panda.this.isLazy() ? Panda.this.random.nextInt(50) + 10 : Panda.this.random.nextInt(150) + 10;
  
@@ -60,9 +60,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      protected void finishConversion(ServerLevel world) {
          PiglinAi.cancelAdmiring(this);
-+        this.forceDrops = true; // Paper
++        this.forceDrops = true; // Paper - Add missing forceDrop toggles
          this.inventory.removeAllItems().forEach(this::spawnAtLocation);
-+        this.forceDrops = false; // Paper
++        this.forceDrops = false; // Paper - Add missing forceDrop toggles
          super.finishConversion(world);
      }
  
@@ -74,9 +74,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      private static void holdInOffhand(Piglin piglin, ItemStack stack) {
          if (PiglinAi.isHoldingItemInOffHand(piglin)) {
-+            piglin.forceDrops = true; // Paper
++            piglin.forceDrops = true; // Paper - Add missing forceDrop toggles
              piglin.spawnAtLocation(piglin.getItemInHand(InteractionHand.OFF_HAND));
-+            piglin.forceDrops = false; // Paper
++            piglin.forceDrops = false; // Paper - Add missing forceDrop toggles
          }
  
          piglin.holdInOffHand(stack);
@@ -84,9 +84,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      protected static void cancelAdmiring(Piglin piglin) {
          if (PiglinAi.isAdmiringItem(piglin) && !piglin.getOffhandItem().isEmpty()) {
-+            piglin.forceDrops = true; // Paper
++            piglin.forceDrops = true; // Paper - Add missing forceDrop toggles
              piglin.spawnAtLocation(piglin.getOffhandItem());
-+            piglin.forceDrops = false; // Paper
++            piglin.forceDrops = false; // Paper - Add missing forceDrop toggles
              piglin.setItemInHand(InteractionHand.OFF_HAND, ItemStack.EMPTY);
          }
  
@@ -98,9 +98,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              double d0 = (double) this.getEquipmentDropChance(enumitemslot);
  
              if (!itemstack1.isEmpty() && (double) Math.max(this.random.nextFloat() - 0.1F, 0.0F) < d0) {
-+                this.forceDrops = true; // Paper
++                this.forceDrops = true; // Paper - Add missing forceDrop toggles
                  this.spawnAtLocation(itemstack1);
-+                this.forceDrops = false; // Paper
++                this.forceDrops = false; // Paper - Add missing forceDrop toggles
              }
  
              this.onItemPickup(item);

patches/server/Add-option-to-disable-block-updates.patch

@@ -162,7 +162,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
 +        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates) return; // Paper - prevent tripwires from detecting collision
-         if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
+         if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (!world.isClientSide) {
              if (!(Boolean) state.getValue(TripWireBlock.POWERED)) {
 @@ -0,0 +0,0 @@ public class TripWireBlock extends Block {

patches/server/Allow-skipping-writing-of-comments-to-server.propert.patch

@@ -24,7 +24,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
              // CraftBukkit end
 -            BufferedWriter bufferedwriter = Files.newBufferedWriter(path, StandardCharsets.UTF_8);
-+            // Paper start - disable writing comments to properties file
++            // Paper start - allow skipping server.properties comments
 +            java.io.OutputStream outputstream = Files.newOutputStream(path);
 +            java.io.BufferedOutputStream bufferedOutputStream =  !skipComments ? new java.io.BufferedOutputStream(outputstream) : new java.io.BufferedOutputStream(outputstream) {
 +                private boolean isRightAfterNewline = true; // If last written char was newline
@@ -63,7 +63,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                }
 +            };
 +            BufferedWriter bufferedwriter = new BufferedWriter(new java.io.OutputStreamWriter(bufferedOutputStream, java.nio.charset.StandardCharsets.UTF_8.newEncoder()));
-+            // Paper end
++            // Paper end - allow skipping server.properties comments
  
              try {
                  this.properties.store(bufferedwriter, "Minecraft server properties");

patches/server/Change-EnderEye-target-without-changing-other-things.patch

@@ -12,11 +12,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public void signalTo(BlockPos pos) {
-+        // Paper start
++        // Paper start - Change EnderEye target without changing other things
 +        this.signalTo(pos, true);
 +    }
 +    public void signalTo(BlockPos pos, boolean update) {
-+        // Paper end
++        // Paper end - Change EnderEye target without changing other things
          double d0 = (double) pos.getX();
          int i = pos.getY();
          double d1 = (double) pos.getZ();
@@ -24,10 +24,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.tz = d1;
          }
  
-+        if (update) { // Paper
++        if (update) { // Paper - Change EnderEye target without changing other things
          this.life = 0;
          this.surviveAfterDeath = this.random.nextInt(5) > 0;
-+        } // Paper
++        } // Paper - Change EnderEye target without changing other things
      }
  
      @Override
@@ -39,16 +39,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void setTargetLocation(Location location) {
-+        // Paper start
++        // Paper start - Change EnderEye target without changing other things
 +        this.setTargetLocation(location, true);
 +    }
 +
 +    @Override
 +    public void setTargetLocation(Location location, boolean update) {
-+        // Paper end
++        // Paper end - Change EnderEye target without changing other things
          Preconditions.checkArgument(this.getWorld().equals(location.getWorld()), "Cannot target EnderSignal across worlds");
 -        this.getHandle().signalTo(CraftLocation.toBlockPosition(location));
-+        this.getHandle().signalTo(CraftLocation.toBlockPosition(location), update); // Paper
++        this.getHandle().signalTo(CraftLocation.toBlockPosition(location), update); // Paper - Change EnderEye target without changing other things
      }
  
      @Override

patches/server/Clear-bucket-NBT-after-dispense.patch

@@ -14,7 +14,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      if (stack.isEmpty()) {
 -                        stack.setItem(Items.BUCKET);
 -                        stack.setCount(1);
-+                        stack = new ItemStack(item); // Paper - clear tag
++                        stack = new ItemStack(item); // Paper - Clear bucket NBT after dispense
                      } else if (pointer.blockEntity().addItem(new ItemStack(item)) < 0) {
                          this.defaultDispenseItemBehavior.dispense(pointer, new ItemStack(item));
                      }

patches/server/Config-option-for-Piglins-guarding-chests.patch

@@ -12,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public static void angerNearbyPiglins(Player player, boolean blockOpen) {
-+        if (!player.level().paperConfig().entities.behavior.piglinsGuardChests) return; // Paper
++        if (!player.level().paperConfig().entities.behavior.piglinsGuardChests) return; // Paper - Config option for Piglins guarding chests
          List<Piglin> list = player.level().getEntitiesOfClass(Piglin.class, player.getBoundingBox().inflate(16.0D));
  
          list.stream().filter(PiglinAi::isIdle).filter((entitypiglin) -> {

patches/server/Expand-EntityUnleashEvent.patch

@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Nassim Jahnke <nassim@njahnke.dev>
 Date: Fri, 29 Jan 2021 15:13:11 +0100
-Subject: [PATCH] Add dropLeash variable to EntityUnleashEvent
+Subject: [PATCH] Expand EntityUnleashEvent
 
 
 diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
@@ -48,7 +48,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -            this.dropLeash(true, true);
 +            // Paper start - drop leash variable
 +            EntityUnleashEvent event = new EntityUnleashEvent(this.getBukkitEntity(), EntityUnleashEvent.UnleashReason.UNKNOWN, true);
-+            this.level().getCraftServer().getPluginManager().callEvent(event); // CraftBukkit
++            if (!event.callEvent()) { return flag1; }
 +            this.dropLeash(true, event.isDropLeash());
 +            // Paper end
          }
@@ -62,7 +62,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -        this.dropLeash(true, false);
 +        // Paper start - drop leash variable
 +        EntityUnleashEvent event = new EntityUnleashEvent(this.getBukkitEntity(), EntityUnleashEvent.UnleashReason.UNKNOWN, false);
-+        this.level().getCraftServer().getPluginManager().callEvent(event); // CraftBukkit
++        if (!event.callEvent()) { return; }
 +        this.dropLeash(true, event.isDropLeash());
 +        // Paper end
          this.getAllSlots().forEach((itemstack) -> {

patches/server/Expand-PlayerItemDamageEvent.patch

@@ -15,9 +15,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                int originalDamage = amount; // Paper - Expand PlayerItemDamageEvent
                  amount -= k;
                  // CraftBukkit start
-                 if (player instanceof ServerPlayer serverPlayer) { // Paper
--                    PlayerItemDamageEvent event = new PlayerItemDamageEvent(serverPlayer.getBukkitEntity(), CraftItemStack.asCraftMirror(this), amount); // Paper
-+                    PlayerItemDamageEvent event = new PlayerItemDamageEvent(serverPlayer.getBukkitEntity(), CraftItemStack.asCraftMirror(this), amount, originalDamage); // Paper - Expand PlayerItemDamageEvent
+                 if (player instanceof ServerPlayer serverPlayer) { // Paper - Add EntityDamageItemEvent
+-                    PlayerItemDamageEvent event = new PlayerItemDamageEvent(serverPlayer.getBukkitEntity(), CraftItemStack.asCraftMirror(this), amount); // Paper - Add EntityDamageItemEvent
++                    PlayerItemDamageEvent event = new PlayerItemDamageEvent(serverPlayer.getBukkitEntity(), CraftItemStack.asCraftMirror(this), amount, originalDamage); // Paper - Add EntityDamageItemEvent & Expand PlayerItemDamageEvent
                      event.getPlayer().getServer().getPluginManager().callEvent(event);
  
                      if (amount != event.getDamage() || event.isCancelled()) {

patches/server/Fix-PlayerBucketEmptyEvent-result-itemstack.patch

@@ -13,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
  public class BucketItem extends Item implements DispensibleContainerItem {
  
-+    private static @Nullable ItemStack itemLeftInHandAfterPlayerBucketEmptyEvent = null; // Paper
++    private static @Nullable ItemStack itemLeftInHandAfterPlayerBucketEmptyEvent = null; // Paper - Fix PlayerBucketEmptyEvent result itemstack
 +
      public final Fluid content;
  
@@ -22,13 +22,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public static ItemStack getEmptySuccessItem(ItemStack stack, Player player) {
-+        // Paper start
++        // Paper start - Fix PlayerBucketEmptyEvent result itemstack
 +        if (itemLeftInHandAfterPlayerBucketEmptyEvent != null) {
 +            ItemStack itemInHand = itemLeftInHandAfterPlayerBucketEmptyEvent;
 +            itemLeftInHandAfterPlayerBucketEmptyEvent = null;
 +            return itemInHand;
 +        }
-+        // Paper end
++        // Paper end - Fix PlayerBucketEmptyEvent result itemstack
          return !player.getAbilities().instabuild ? new ItemStack(Items.BUCKET) : stack;
      }
  
@@ -36,7 +36,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      ((ServerPlayer) entityhuman).getBukkitEntity().updateInventory(); // SPIGOT-4541
                      return false;
                  }
-+                itemLeftInHandAfterPlayerBucketEmptyEvent = event.getItemStack() != null ? event.getItemStack().equals(CraftItemStack.asNewCraftStack(net.minecraft.world.item.Items.BUCKET)) ? null : CraftItemStack.asNMSCopy(event.getItemStack()) : ItemStack.EMPTY; // Paper - fix empty event result itemstack
++                itemLeftInHandAfterPlayerBucketEmptyEvent = event.getItemStack() != null ? event.getItemStack().equals(CraftItemStack.asNewCraftStack(net.minecraft.world.item.Items.BUCKET)) ? null : CraftItemStack.asNMSCopy(event.getItemStack()) : ItemStack.EMPTY; // Paper - Fix PlayerBucketEmptyEvent result itemstack
              }
              // CraftBukkit end
              if (!flag2) {

patches/server/Fix-PlayerDropItemEvent-using-wrong-item.patch

@@ -13,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              if (retainOwnership) {
                  if (!itemstack1.isEmpty()) {
 -                    this.awardStat(Stats.ITEM_DROPPED.get(itemstack1.getItem()), stack.getCount());
-+                    this.awardStat(Stats.ITEM_DROPPED.get(itemstack1.getItem()), itemstack1.getCount()); // Paper
++                    this.awardStat(Stats.ITEM_DROPPED.get(itemstack1.getItem()), itemstack1.getCount()); // Paper - Fix PlayerDropItemEvent using wrong item
                  }
  
                  this.awardStat(Stats.DROP);

patches/server/Fix-a-bunch-of-vanilla-bugs.patch

@@ -446,7 +446,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/level/block/LayeredCauldronBlock.java
 +++ b/src/main/java/net/minecraft/world/level/block/LayeredCauldronBlock.java
 @@ -0,0 +0,0 @@ public class LayeredCauldronBlock extends AbstractCauldronBlock {
-         if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
+         if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (!world.isClientSide && entity.isOnFire() && this.isEntityInsideContent(state, pos, entity)) {
              // CraftBukkit start
 -            if (entity.mayInteract(world, pos)) {

patches/server/Fix-and-optimise-world-force-upgrading.patch

@@ -279,7 +279,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -                    return true;
 -                }, dimensions);
 -            }
-+            // Paper - move down
++            // Paper - fix and optimise world upgrading; move down
  
              PrimaryLevelData iworlddataserver = worlddata;
              boolean flag = worlddata.isDebugWorld();
@@ -362,7 +362,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -        if (this.console.options.has("forceUpgrade")) {
 -            net.minecraft.server.Main.forceUpgrade(worldSession, DataFixers.getDataFixer(), this.console.options.has("eraseCache"), () -> true, iregistry);
 -        }
-+        // Paper - move down
++        // Paper - fix and optimise world upgrading; move down
  
          long j = BiomeManager.obfuscateSeed(creator.seed());
          List<CustomSpawner> list = ImmutableList.of(new PhantomSpawner(), new PatrolSpawner(), new CatSpawner(), new VillageSiege(), new WanderingTraderSpawner(worlddata));

patches/server/Fix-commands-from-signs-not-firing-command-events.patch

@@ -66,7 +66,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
              if (chatclickable != null && chatclickable.getAction() == ClickEvent.Action.RUN_COMMAND) {
 -                player.getServer().getCommands().performPrefixedCommand(this.createCommandSourceStack(player, world, pos), chatclickable.getValue());
-+                // Paper start
++                // Paper start - Fix commands from signs not firing command events
 +                String command = chatclickable.getValue().startsWith("/") ? chatclickable.getValue() : "/" + chatclickable.getValue();
 +                if (org.spigotmc.SpigotConfig.logCommands)  {
 +                    LOGGER.info("{} issued server command: {}", player.getScoreboardName(), command);
@@ -76,7 +76,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                    return false;
 +                }
 +                player.getServer().getCommands().performPrefixedCommand(this.createCommandSourceStack(((org.bukkit.craftbukkit.entity.CraftPlayer) event.getPlayer()).getHandle(), world, pos), event.getMessage());
-+                // Paper end
++                // Paper end - Fix commands from signs not firing command events
                  flag1 = true;
              }
          }
@@ -84,7 +84,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          String s = player == null ? "Sign" : player.getName().getString();
          Object object = player == null ? Component.literal("Sign") : player.getDisplayName();
  
-+        // Paper start - send messages back to the player
++        // Paper start - Fix commands from signs not firing command events
 +        CommandSource commandSource = this.level.paperConfig().misc.showSignClickCommandFailureMsgsToPlayer ? new io.papermc.paper.commands.DelegatingCommandSource(this) {
 +            @Override
 +            public void sendSystemMessage(Component message) {
@@ -98,10 +98,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                return true;
 +            }
 +        } : this;
-+        // Paper end
++        // Paper end - Fix commands from signs not firing command events
          // CraftBukkit - this
 -        return new CommandSourceStack(this, Vec3.atCenterOf(pos), Vec2.ZERO, (ServerLevel) world, 2, s, (Component) object, world.getServer(), player);
-+        return new CommandSourceStack(commandSource, Vec3.atCenterOf(pos), Vec2.ZERO, (ServerLevel) world, 2, s, (Component) object, world.getServer(), player); // Paper
++        return new CommandSourceStack(commandSource, Vec3.atCenterOf(pos), Vec2.ZERO, (ServerLevel) world, 2, s, (Component) object, world.getServer(), player); // Paper - Fix commands from signs not firing command events
      }
  
      @Override
@@ -114,7 +114,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
          try {
 -            return this.server.dispatchCommand(sender, context.getInput()) ? 1 : 0;
-+            return this.server.dispatchCommand(sender, context.getRange().get(context.getInput())) ? 1 : 0; // Paper - actually use the StringRange from context
++            return this.server.dispatchCommand(sender, context.getRange().get(context.getInput())) ? 1 : 0; // Paper - Fix commands from signs not firing command events; actually use the StringRange from context
          } catch (CommandException ex) {
              sender.sendMessage(org.bukkit.ChatColor.RED + "An internal error occurred while attempting to perform this command");
              this.server.getLogger().log(Level.SEVERE, null, ex);

patches/server/Fix-invulnerable-end-crystals.patch

@@ -31,7 +31,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                    this.setBeamTarget(null);
 +                }
 +            }
-+            // Paper end
++            // Paper end - Fix invulnerable end crystals
          }
  
      }
@@ -59,7 +59,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              endCrystal.setBeamTarget(config.getCrystalBeamTarget());
              endCrystal.setInvulnerable(config.isCrystalInvulnerable());
              endCrystal.moveTo((double)spike.getCenterX() + 0.5D, (double)(spike.getHeight() + 1), (double)spike.getCenterZ() + 0.5D, random.nextFloat() * 360.0F, 0.0F);
-+        endCrystal.generatedByDragonFight = true; // Paper
++            endCrystal.generatedByDragonFight = true; // Paper - Fix invulnerable end crystals
              world.addFreshEntity(endCrystal);
              BlockPos blockPos2 = endCrystal.blockPosition();
              this.setBlock(world, blockPos2.below(), Blocks.BEDROCK.defaultBlockState());

patches/server/Fix-kick-event-leave-message-not-being-sent.patch

@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Jake Potrebic <jake.m.potrebic@gmail.com>
 Date: Wed, 7 Jul 2021 16:19:41 -0700
-Subject: [PATCH] Fixes kick event leave message not being sent
+Subject: [PATCH] Fix kick event leave message not being sent
 
 
 diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
@@ -24,11 +24,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void onDisconnect(Component reason) {
-+        // Paper start
++        // Paper start - Fix kick event leave message not being sent
 +        this.onDisconnect(reason, null);
 +    }
 +    public void onDisconnect(Component reason, @Nullable net.kyori.adventure.text.Component quitMessage) {
-+        // Paper end
++        // Paper end - Fix kick event leave message not being sent
          if (this.isSingleplayerOwner()) {
              ServerCommonPacketListenerImpl.LOGGER.info("Stopping singleplayer server as player logged out");
              this.server.halt(false);
@@ -57,12 +57,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void onDisconnect(Component reason) {
-+        // Paper start
++        // Paper start - Fix kick event leave message not being sent
 +        this.onDisconnect(reason, null);
 +    }
 +    @Override
 +    public void onDisconnect(Component reason, @Nullable net.kyori.adventure.text.Component quitMessage) {
-+        // Paper end
++        // Paper end - Fix kick event leave message not being sent
          // CraftBukkit start - Rarely it would send a disconnect line twice
          if (this.processedDisconnect) {
              return;
@@ -72,17 +72,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          ServerGamePacketListenerImpl.LOGGER.info("{} lost connection: {}", this.player.getName().getString(), reason.getString());
 -        this.removePlayerFromWorld();
 -        super.onDisconnect(reason);
-+        this.removePlayerFromWorld(quitMessage); // Paper
-+        super.onDisconnect(reason, quitMessage); // Paper
++        this.removePlayerFromWorld(quitMessage); // Paper - Fix kick event leave message not being sent
++        super.onDisconnect(reason, quitMessage); // Paper - Fix kick event leave message not being sent
      }
  
-+    // Paper start
++    // Paper start - Fix kick event leave message not being sent
      private void removePlayerFromWorld() {
 +        this.removePlayerFromWorld(null);
 +    }
 +
 +    private void removePlayerFromWorld(@Nullable net.kyori.adventure.text.Component quitMessage) {
-+        // Paper end
++        // Paper end - Fix kick event leave message not being sent
          this.chatMessageChain.close();
          // CraftBukkit start - Replace vanilla quit message handling with our own.
          /*
@@ -103,11 +103,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public net.kyori.adventure.text.Component remove(ServerPlayer entityplayer) { // CraftBukkit - return string // Paper - return Component
-+        // Paper start
++        // Paper start - Fix kick event leave message not being sent
 +        return this.remove(entityplayer, net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, io.papermc.paper.configuration.GlobalConfiguration.get().messages.useDisplayNameInQuitMessage ? entityplayer.getBukkitEntity().displayName() : io.papermc.paper.adventure.PaperAdventure.asAdventure(entityplayer.getDisplayName())));
 +    }
 +    public net.kyori.adventure.text.Component remove(ServerPlayer entityplayer, net.kyori.adventure.text.Component leaveMessage) {
-+        // Paper end
++        // Paper end - Fix kick event leave message not being sent
          ServerLevel worldserver = entityplayer.serverLevel();
  
          entityplayer.awardStat(Stats.LEAVE_GAME);

patches/server/Fix-new-block-data-for-EntityChangeBlockEvent.patch

@@ -187,7 +187,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/level/block/WaterlilyBlock.java
 +++ b/src/main/java/net/minecraft/world/level/block/WaterlilyBlock.java
 @@ -0,0 +0,0 @@ public class WaterlilyBlock extends BushBlock {
-         if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
+         if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (world instanceof ServerLevel && entity instanceof Boat) {
              // CraftBukkit start
 -            if (!CraftEventFactory.callEntityChangeBlockEvent(entity, pos, Blocks.AIR.defaultBlockState())) {

patches/server/Fix-potions-splash-events.patch

@@ -15,11 +15,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              Potion potionregistry = PotionUtils.getPotion(itemstack);
              List<MobEffectInstance> list = PotionUtils.getMobEffects(itemstack);
              boolean flag = potionregistry == Potions.WATER && list.isEmpty();
-+            boolean showParticles = true; // Paper
++            boolean showParticles = true; // Paper - Fix potions splash events
  
              if (flag) {
 -                this.applyWater();
-+                showParticles = this.applyWater(); // Paper
++                showParticles = this.applyWater(); // Paper - Fix potions splash events
              } else if (true || !list.isEmpty()) { // CraftBukkit - Call event even if no effects to apply
                  if (this.isLingering()) {
 -                    this.makeAreaOfEffectCloud(itemstack, potionregistry, hitResult); // CraftBukkit - Pass MovingObjectPosition
@@ -30,21 +30,21 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  }
              }
  
-+            if (showParticles) { // Paper
++            if (showParticles) { // Paper - Fix potions splash events
              int i = potionregistry.hasInstantEffects() ? 2007 : 2002;
  
              this.level().levelEvent(i, this.blockPosition(), PotionUtils.getColor(itemstack));
-+            } // Paper
++            } // Paper - Fix potions splash events
              this.discard();
          }
      }
  
 -    private void applyWater() {
-+    private static final Predicate<net.minecraft.world.entity.LivingEntity> APPLY_WATER_GET_ENTITIES_PREDICATE = ThrownPotion.WATER_SENSITIVE_OR_ON_FIRE.or(Axolotl.class::isInstance); // Paper
-+    private boolean applyWater() { // Paper
++    private static final Predicate<net.minecraft.world.entity.LivingEntity> APPLY_WATER_GET_ENTITIES_PREDICATE = ThrownPotion.WATER_SENSITIVE_OR_ON_FIRE.or(Axolotl.class::isInstance); // Paper - Fix potions splash events
++    private boolean applyWater() { // Paper - Fix potions splash events
          AABB axisalignedbb = this.getBoundingBox().inflate(4.0D, 2.0D, 4.0D);
 -        List<net.minecraft.world.entity.LivingEntity> list = this.level().getEntitiesOfClass(net.minecraft.world.entity.LivingEntity.class, axisalignedbb, ThrownPotion.WATER_SENSITIVE_OR_ON_FIRE);
-+        // Paper start
++        // Paper start - Fix potions splash events
 +        List<net.minecraft.world.entity.LivingEntity> list = this.level().getEntitiesOfClass(net.minecraft.world.entity.LivingEntity.class, axisalignedbb, ThrownPotion.APPLY_WATER_GET_ENTITIES_PREDICATE);
 +        Map<LivingEntity, Double> affected = new HashMap<>();
 +        java.util.Set<LivingEntity> rehydrate = new java.util.HashSet<>();
@@ -93,14 +93,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                    axolotl.rehydrate();
 +                }
 +            }
-+            // Paper end
++            // Paper end - Fix potions splash events
          }
-+        return !event.isCancelled(); // Paper
++        return !event.isCancelled(); // Paper - Fix potions splash events
  
      }
  
 -    private void applySplash(List<MobEffectInstance> list, @Nullable Entity entity, HitResult position) { // CraftBukkit - Pass MovingObjectPosition
-+    private boolean applySplash(List<MobEffectInstance> list, @Nullable Entity entity, HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - return boolean
++    private boolean applySplash(List<MobEffectInstance> list, @Nullable Entity entity, HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - Fix potions splash events
          AABB axisalignedbb = this.getBoundingBox().inflate(4.0D, 2.0D, 4.0D);
          List<net.minecraft.world.entity.LivingEntity> list1 = this.level().getEntitiesOfClass(net.minecraft.world.entity.LivingEntity.class, axisalignedbb);
          Map<LivingEntity, Double> affected = new HashMap<LivingEntity, Double>(); // CraftBukkit
@@ -116,7 +116,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  }
              }
          }
-+        return !event.isCancelled(); // Paper
++        return !event.isCancelled(); // Paper - Fix potions splash events
  
      }
  
@@ -129,12 +129,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          entityareaeffectcloud.setPotion(potionregistry);
          Iterator iterator = PotionUtils.getCustomEffects(itemstack).iterator();
  
-+        boolean noEffects = potionregistry.getEffects().isEmpty(); // Paper
++        boolean noEffects = potionregistry.getEffects().isEmpty(); // Paper - Fix potions splash events
          while (iterator.hasNext()) {
              MobEffectInstance mobeffect = (MobEffectInstance) iterator.next();
  
              entityareaeffectcloud.addEffect(new MobEffectInstance(mobeffect));
-+            noEffects = false; // Paper
++            noEffects = false; // Paper - Fix potions splash events
          }
  
          CompoundTag nbttagcompound = itemstack.getTag();
@@ -149,7 +149,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              entityareaeffectcloud.discard();
          }
          // CraftBukkit end
-+        return !event.isCancelled(); // Paper
++        return !event.isCancelled(); // Paper - Fix potions splash events
      }
  
      public boolean isLingering() {

patches/server/Improve-boat-collision-performance.patch

@@ -12,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }).findFirst().orElseThrow(() -> {
          return new IllegalStateException("No jar file system provider found");
      });
-+    public static final double COLLISION_EPSILON = 1.0E-7; // Paper
++    public static final double COLLISION_EPSILON = 1.0E-7; // Paper - Improve boat collision performance
      private static Consumer<String> thePauser = (message) -> {
      };
  
@@ -25,7 +25,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      Entity entity = source.getDirectEntity();
  
 -                    if (entity instanceof LivingEntity) {
-+                    if (entity instanceof LivingEntity && entity.distanceToSqr(this) <= (200.0D * 200.0D)) { // Paper
++                    if (entity instanceof LivingEntity && entity.distanceToSqr(this) <= (200.0D * 200.0D)) { // Paper - Improve boat collision performance
                          LivingEntity entityliving = (LivingEntity) entity;
  
                          this.blockUsingShield(entityliving);
@@ -34,13 +34,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
                  if (entity1 != null && !source.is(DamageTypeTags.NO_KNOCKBACK)) {
 -                    double d0 = entity1.getX() - this.getX();
-+                    final boolean far = entity1.distanceToSqr(this) > (200.0 * 200.0); // Paper
-+                    double d0 = far ? (Math.random() - Math.random()) : entity1.getX() - this.getX(); // Paper
++                    final boolean far = entity1.distanceToSqr(this) > (200.0 * 200.0); // Paper - Improve boat collision performance
++                    double d0 = far ? (Math.random() - Math.random()) : entity1.getX() - this.getX(); // Paper - Improve boat collision performance
  
                      double d1;
  
 -                    for (d1 = entity1.getZ() - this.getZ(); d0 * d0 + d1 * d1 < 1.0E-4D; d1 = (Math.random() - Math.random()) * 0.01D) {
-+                    for (d1 = far ? Math.random() - Math.random() : entity1.getZ() - this.getZ(); d0 * d0 + d1 * d1 < 1.0E-4D; d1 = (Math.random() - Math.random()) * 0.01D) { // Paper
++                    for (d1 = far ? Math.random() - Math.random() : entity1.getZ() - this.getZ(); d0 * d0 + d1 * d1 < 1.0E-4D; d1 = (Math.random() - Math.random()) * 0.01D) { // Paper - Improve boat collision performance
                          d0 = (Math.random() - Math.random()) * 0.01D;
                      }
  
@@ -49,7 +49,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  Entity entity = damagesource.getDirectEntity();
  
 -                if (entity instanceof LivingEntity) {
-+                if (entity instanceof LivingEntity && entity.distanceToSqr(this) <= (200.0D * 200.0D)) { // Paper
++                if (entity instanceof LivingEntity && entity.distanceToSqr(this) <= (200.0D * 200.0D)) { // Paper - Improve boat collision performance
                      this.blockUsingShield((LivingEntity) entity);
                  }
              }
@@ -63,8 +63,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.waterLevel = this.getY(1.0D);
 -            this.setPos(this.getX(), (double) (this.getWaterLevelAbove() - this.getBbHeight()) + 0.101D, this.getZ());
 -            this.setDeltaMovement(this.getDeltaMovement().multiply(1.0D, 0.0D, 1.0D));
-+            this.move(MoverType.SELF, new Vec3(0.0, ((double) (this.getWaterLevelAbove() - this.getBbHeight()) + 0.101D) - this.getY(), 0.0)); // Paper
-+            this.setDeltaMovement(this.getDeltaMovement().multiply(1.0D, 0.0D, 1.0D)); // Paper
++            this.move(MoverType.SELF, new Vec3(0.0, ((double) (this.getWaterLevelAbove() - this.getBbHeight()) + 0.101D) - this.getY(), 0.0)); // Paper - Improve boat collision performance
++            this.setDeltaMovement(this.getDeltaMovement().multiply(1.0D, 0.0D, 1.0D)); // Paper - Improve boat collision performance
              this.lastYd = 0.0D;
              this.status = Boat.Status.IN_WATER;
          } else {

patches/server/Limit-item-frame-cursors-on-maps.patch

@@ -12,10 +12,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
              MapFrame worldmapframe1 = new MapFrame(blockposition, entityitemframe.getDirection().get2DDataValue() * 90, entityitemframe.getId());
  
-+            if (this.decorations.size() < player.level().paperConfig().maps.itemFrameCursorLimit) { // Paper
++            if (this.decorations.size() < player.level().paperConfig().maps.itemFrameCursorLimit) { // Paper - Limit item frame cursors on maps
              this.addDecoration(MapDecoration.Type.FRAME, player.level(), "frame-" + entityitemframe.getId(), (double) blockposition.getX(), (double) blockposition.getZ(), (double) (entityitemframe.getDirection().get2DDataValue() * 90), (Component) null);
              this.frameMarkers.put(worldmapframe1.getId(), worldmapframe1);
-+            } // Paper
++            } // Paper - Limit item frame cursors on maps
          }
  
          CompoundTag nbttagcompound = stack.getTag();
@@ -24,7 +24,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
  
 -            if (!this.isTrackedCountOverLimit(256)) {
-+            if (!this.isTrackedCountOverLimit(((Level) world).paperConfig().maps.itemFrameCursorLimit)) { // Paper
++            if (!this.isTrackedCountOverLimit(((Level) world).paperConfig().maps.itemFrameCursorLimit)) { // Paper - Limit item frame cursors on maps
                  this.bannerMarkers.put(mapiconbanner.getId(), mapiconbanner);
                  this.addDecoration(mapiconbanner.getDecoration(), world, mapiconbanner.getId(), d0, d1, 180.0D, mapiconbanner.getName());
                  return true;

patches/server/Line-Of-Sight-Changes.patch

@@ -14,7 +14,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 -            return vec3d1.distanceTo(vec3d) > 128.0D ? false : this.level().clipDirect(vec3d, vec3d1, net.minecraft.world.phys.shapes.CollisionContext.of(this)) == HitResult.Type.MISS; // Paper
 +            // Paper - diff on change - used in CraftLivingEntity#hasLineOfSight(Location) and CraftWorld#lineOfSightExists
-+            return vec3d1.distanceToSqr(vec3d) > 128.0D * 128.0D ? false : this.level().clipDirect(vec3d, vec3d1, net.minecraft.world.phys.shapes.CollisionContext.of(this)) == HitResult.Type.MISS; // Paper
++            return vec3d1.distanceToSqr(vec3d) > 128.0D * 128.0D ? false : this.level().clipDirect(vec3d, vec3d1, net.minecraft.world.phys.shapes.CollisionContext.of(this)) == HitResult.Type.MISS; // Paper - Perf: Use distance squared
          }
      }
  

patches/server/Make-EntityUnleashEvent-cancellable.patch

@@ -1,41 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Sun, 3 Jan 2021 21:25:31 -0800
-Subject: [PATCH] Make EntityUnleashEvent cancellable
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/Mob.java
-+++ b/src/main/java/net/minecraft/world/entity/Mob.java
-@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements Targeting {
-         if (flag1 && this.isLeashed()) {
-             // Paper start - drop leash variable
-             EntityUnleashEvent event = new EntityUnleashEvent(this.getBukkitEntity(), EntityUnleashEvent.UnleashReason.UNKNOWN, true);
--            this.level().getCraftServer().getPluginManager().callEvent(event); // CraftBukkit
-+            if (!event.callEvent()) { return flag1; }
-             this.dropLeash(true, event.isDropLeash());
-             // Paper end
-         }
-diff --git a/src/main/java/net/minecraft/world/entity/PathfinderMob.java b/src/main/java/net/minecraft/world/entity/PathfinderMob.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/PathfinderMob.java
-+++ b/src/main/java/net/minecraft/world/entity/PathfinderMob.java
-@@ -0,0 +0,0 @@ public abstract class PathfinderMob extends Mob {
-                 if (f > entity.level().paperConfig().misc.maxLeashDistance) { // Paper
-                     // Paper start - drop leash variable
-                     EntityUnleashEvent event = new EntityUnleashEvent(this.getBukkitEntity(), EntityUnleashEvent.UnleashReason.DISTANCE, true);
--                    this.level().getCraftServer().getPluginManager().callEvent(event); // CraftBukkit
-+                    if (!event.callEvent()) { return; }
-                     this.dropLeash(true, event.isDropLeash());
-                     // Paper end
-                 }
-@@ -0,0 +0,0 @@ public abstract class PathfinderMob extends Mob {
-             if (f > entity.level().paperConfig().misc.maxLeashDistance) { // Paper
-                 // Paper start - drop leash variable
-                 EntityUnleashEvent event = new EntityUnleashEvent(this.getBukkitEntity(), EntityUnleashEvent.UnleashReason.DISTANCE, true);
--                this.level().getCraftServer().getPluginManager().callEvent(event); // CraftBukkit
-+                if (!event.callEvent()) { return; }
-                 this.dropLeash(true, event.isDropLeash());
-                 // Paper end
-                 this.goalSelector.disableControlFlag(Goal.Flag.MOVE);

patches/server/Make-hoppers-respect-inventory-max-stack-size.patch

@@ -12,19 +12,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
              if (itemstack1.isEmpty()) {
                  // Spigot start - SPIGOT-6693, InventorySubcontainer#setItem
-+                ItemStack leftover = ItemStack.EMPTY; // Paper
++                ItemStack leftover = ItemStack.EMPTY; // Paper - Make hoppers respect inventory max stack size
                  if (!stack.isEmpty() && stack.getCount() > to.getMaxStackSize()) {
-+                    leftover = stack; // Paper
++                    leftover = stack; // Paper - Make hoppers respect inventory max stack size
                      stack = stack.split(to.getMaxStackSize());
                  }
                  // Spigot end
                  to.setItem(slot, stack);
 -                stack = ItemStack.EMPTY;
-+                stack = leftover; // Paper
++                stack = leftover; // Paper - Make hoppers respect inventory max stack size
                  flag = true;
              } else if (HopperBlockEntity.canMergeItems(itemstack1, stack)) {
 -                int j = stack.getMaxStackSize() - itemstack1.getCount();
-+                int j = Math.min(stack.getMaxStackSize(), to.getMaxStackSize()) - itemstack1.getCount(); // Paper
++                int j = Math.min(stack.getMaxStackSize(), to.getMaxStackSize()) - itemstack1.getCount(); // Paper - Make hoppers respect inventory max stack size
                  int k = Math.min(stack.getCount(), j);
  
                  stack.shrink(k);

patches/server/More-Enchantment-API.patch

@@ -17,7 +17,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public boolean isCursed() {
 -        return this.handle instanceof BindingCurseEnchantment || this.handle instanceof VanishingCurseEnchantment;
-+        return this.handle.isCurse(); // Paper
++        return this.handle.isCurse(); // Paper - More Enchantment API
      }
  
      @Override

patches/server/More-Projectile-API.patch

@@ -48,8 +48,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      }
  
--    private boolean applySplash(List<MobEffectInstance> list, @Nullable Entity entity, HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - return boolean
-+    private boolean applySplash(List<MobEffectInstance> list, @Nullable Entity entity, @Nullable HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - return boolean & More projectile API
+-    private boolean applySplash(List<MobEffectInstance> list, @Nullable Entity entity, HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - Fix potions splash events
++    private boolean applySplash(List<MobEffectInstance> list, @Nullable Entity entity, @Nullable HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - Fix potions splash events & More projectile API
          AABB axisalignedbb = this.getBoundingBox().inflate(4.0D, 2.0D, 4.0D);
          List<net.minecraft.world.entity.LivingEntity> list1 = this.level().getEntitiesOfClass(net.minecraft.world.entity.LivingEntity.class, axisalignedbb);
          Map<LivingEntity, Double> affected = new HashMap<LivingEntity, Double>(); // CraftBukkit

patches/server/Move-range-check-for-block-placing-up.patch

@@ -16,7 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            if (!Double.isFinite(vec3d.x) || !Double.isFinite(vec3d.y) || !Double.isFinite(vec3d.z)) {
 +                return;
 +            }
-+            // Paper end
++            // Paper end - improve distance check
              BlockPos blockposition = movingobjectpositionblock.getBlockPos();
              Vec3 vec3d1 = Vec3.atCenterOf(blockposition);
  

patches/server/Optimize-Biome-Mob-Lookups-for-Mob-Spawning.patch

@@ -14,7 +14,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public static class Builder {
 -        private final Map<MobCategory, List<MobSpawnSettings.SpawnerData>> spawners = Stream.of(MobCategory.values()).collect(ImmutableMap.toImmutableMap((mobCategory) -> {
-+        // Paper start - keep track of data in a pair set to give O(1) contains calls - we have to hook removals incase plugins mess with it
++        // Paper start - Perf: keep track of data in a pair set to give O(1) contains calls - we have to hook removals incase plugins mess with it
 +        public static class MobList extends java.util.ArrayList<MobSpawnSettings.SpawnerData> {
 +            java.util.Set<MobSpawnSettings.SpawnerData> biomes = new java.util.HashSet<>();
 +
@@ -51,7 +51,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -            return Lists.newArrayList();
 +            return new MobList(); // Use MobList instead of ArrayList
          }));
-+        // Paper end
++        // Paper end - Perf: keep track of data in a pair set to give O(1) contains calls
          private final Map<EntityType<?>, MobSpawnSettings.MobSpawnCost> mobSpawnCosts = Maps.newLinkedHashMap();
          private float creatureGenerationProbability = 0.1F;
  

patches/server/Optimize-Hoppers.patch

@@ -647,7 +647,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                ignoreTileUpdates = true; // Paper - Perf: Optimize Hoppers
                  to.setItem(slot, stack);
 +                ignoreTileUpdates = false; // Paper - Perf: Optimize Hoppers
-                 stack = leftover; // Paper
+                 stack = leftover; // Paper - Make hoppers respect inventory max stack size
                  flag = true;
              } else if (HopperBlockEntity.canMergeItems(itemstack1, stack)) {
 @@ -0,0 +0,0 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen

patches/server/Optimize-indirect-passenger-iteration.patch

@@ -12,24 +12,24 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      private Stream<Entity> getIndirectPassengersStream() {
-+        if (this.passengers.isEmpty()) { return Stream.of(); } // Paper
++        if (this.passengers.isEmpty()) { return Stream.of(); } // Paper - Optimize indirect passenger iteration
          return this.passengers.stream().flatMap(Entity::getSelfAndPassengers);
      }
  
      @Override
      public Stream<Entity> getSelfAndPassengers() {
-+        if (this.passengers.isEmpty()) { return Stream.of(this); } // Paper
++        if (this.passengers.isEmpty()) { return Stream.of(this); } // Paper - Optimize indirect passenger iteration
          return Stream.concat(Stream.of(this), this.getIndirectPassengersStream());
      }
  
      @Override
      public Stream<Entity> getPassengersAndSelf() {
-+        if (this.passengers.isEmpty()) { return Stream.of(this); } // Paper
++        if (this.passengers.isEmpty()) { return Stream.of(this); } // Paper - Optimize indirect passenger iteration
          return Stream.concat(this.passengers.stream().flatMap(Entity::getPassengersAndSelf), Stream.of(this));
      }
  
      public Iterable<Entity> getIndirectPassengers() {
-+        // Paper start - rewrite this method
++        // Paper start - Optimize indirect passenger iteration
 +        if (this.passengers.isEmpty()) { return ImmutableList.of(); }
 +        ImmutableList.Builder<Entity> indirectPassengers = ImmutableList.builder();
 +        for (Entity passenger : this.passengers) {
@@ -39,7 +39,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return indirectPassengers.build();
 +    }
 +    private Iterable<Entity> getIndirectPassengers_old() {
-+        // Paper end
++        // Paper end - Optimize indirect passenger iteration
          return () -> {
              return this.getIndirectPassengersStream().iterator();
          };
@@ -47,7 +47,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      // Paper end - rewrite chunk system
  
      public boolean hasExactlyOnePlayerPassenger() {
-+        if (this.passengers.isEmpty()) { return false; } // Paper
++        if (this.passengers.isEmpty()) { return false; } // Paper - Optimize indirect passenger iteration
          return this.countPlayerPassengers() == 1;
      }
  

patches/server/Option-to-prevent-NBT-copy-in-smithing-recipes.patch

@@ -12,15 +12,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      final Ingredient base;
      final Ingredient addition;
      final ItemStack result;
-+    final boolean copyNBT; // Paper
++    final boolean copyNBT; // Paper - Option to prevent NBT copy
  
      public SmithingTransformRecipe(Ingredient template, Ingredient base, Ingredient addition, ItemStack result) {
-+        // Paper start
++        // Paper start - Option to prevent NBT copy
 +        this(template, base, addition, result, true);
 +    }
 +    public SmithingTransformRecipe(Ingredient template, Ingredient base, Ingredient addition, ItemStack result, boolean copyNBT) {
 +        this.copyNBT = copyNBT;
-+        // Paper end
++        // Paper end - Option to prevent NBT copy
          this.template = template;
          this.base = base;
          this.addition = addition;
@@ -28,13 +28,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public ItemStack assemble(Container inventory, RegistryAccess registryManager) {
          ItemStack itemstack = this.result.copy();
-+        if (this.copyNBT) { // Paper - copy nbt conditionally
++        if (this.copyNBT) { // Paper - Option to prevent NBT copy
          CompoundTag nbttagcompound = inventory.getItem(1).getTag();
  
          if (nbttagcompound != null) {
              itemstack.setTag(nbttagcompound.copy());
          }
-+        } // Paper
++        } // Paper - Option to prevent NBT copy
  
          return itemstack;
      }
@@ -43,7 +43,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          CraftItemStack result = CraftItemStack.asCraftMirror(this.result);
  
 -        CraftSmithingTransformRecipe recipe = new CraftSmithingTransformRecipe(id, result, CraftRecipe.toBukkit(this.template), CraftRecipe.toBukkit(this.base), CraftRecipe.toBukkit(this.addition));
-+        CraftSmithingTransformRecipe recipe = new CraftSmithingTransformRecipe(id, result, CraftRecipe.toBukkit(this.template), CraftRecipe.toBukkit(this.base), CraftRecipe.toBukkit(this.addition), this.copyNBT); // Paper
++        CraftSmithingTransformRecipe recipe = new CraftSmithingTransformRecipe(id, result, CraftRecipe.toBukkit(this.template), CraftRecipe.toBukkit(this.base), CraftRecipe.toBukkit(this.addition), this.copyNBT); // Paper - Option to prevent NBT copy
  
          return recipe;
      }
@@ -55,15 +55,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      final Ingredient template;
      final Ingredient base;
      final Ingredient addition;
-+    final boolean copyNbt; // Paper
++    final boolean copyNbt; // Paper - Option to prevent NBT copy
  
      public SmithingTrimRecipe(Ingredient template, Ingredient base, Ingredient addition) {
-+        // Paper start
++        // Paper start - Option to prevent NBT copy
 +        this(template, base, addition, true);
 +    }
 +    public SmithingTrimRecipe(Ingredient template, Ingredient base, Ingredient addition, boolean copyNbt) {
 +        this.copyNbt = copyNbt;
-+        // Paper end
++        // Paper end - Option to prevent NBT copy
          this.template = template;
          this.base = base;
          this.addition = addition;
@@ -72,7 +72,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  }
  
 -                ItemStack itemstack1 = itemstack.copy();
-+                ItemStack itemstack1 = this.copyNbt ? itemstack.copy() : new ItemStack(itemstack.getItem(), itemstack.getCount()); // Paper
++                ItemStack itemstack1 = this.copyNbt ? itemstack.copy() : new ItemStack(itemstack.getItem(), itemstack.getCount()); // Paper - Option to prevent NBT copy
  
                  itemstack1.setCount(1);
                  ArmorTrim armortrim = new ArmorTrim((Holder) optional.get(), (Holder) optional1.get());
@@ -81,7 +81,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public Recipe toBukkitRecipe(NamespacedKey id) {
 -        return new CraftSmithingTrimRecipe(id, CraftRecipe.toBukkit(this.template), CraftRecipe.toBukkit(this.base), CraftRecipe.toBukkit(this.addition));
-+        return new CraftSmithingTrimRecipe(id, CraftRecipe.toBukkit(this.template), CraftRecipe.toBukkit(this.base), CraftRecipe.toBukkit(this.addition), this.copyNbt); // Paper
++        return new CraftSmithingTrimRecipe(id, CraftRecipe.toBukkit(this.template), CraftRecipe.toBukkit(this.base), CraftRecipe.toBukkit(this.addition), this.copyNbt); // Paper - Option to prevent NBT copy
      }
      // CraftBukkit end
  
@@ -93,18 +93,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public CraftSmithingTransformRecipe(NamespacedKey key, ItemStack result, RecipeChoice template, RecipeChoice base, RecipeChoice addition) {
          super(key, result, template, base, addition);
      }
-+    // Paper start
++    // Paper start - Option to prevent NBT copy
 +    public CraftSmithingTransformRecipe(NamespacedKey key, ItemStack result, RecipeChoice template, RecipeChoice base, RecipeChoice addition, boolean copyNbt) {
 +        super(key, result, template, base, addition, copyNbt);
 +    }
-+    // Paper end
++    // Paper endv
  
      public static CraftSmithingTransformRecipe fromBukkitRecipe(SmithingTransformRecipe recipe) {
          if (recipe instanceof CraftSmithingTransformRecipe) {
              return (CraftSmithingTransformRecipe) recipe;
          }
 -        CraftSmithingTransformRecipe ret = new CraftSmithingTransformRecipe(recipe.getKey(), recipe.getResult(), recipe.getTemplate(), recipe.getBase(), recipe.getAddition());
-+        CraftSmithingTransformRecipe ret = new CraftSmithingTransformRecipe(recipe.getKey(), recipe.getResult(), recipe.getTemplate(), recipe.getBase(), recipe.getAddition(), recipe.willCopyNbt()); // Paper
++        CraftSmithingTransformRecipe ret = new CraftSmithingTransformRecipe(recipe.getKey(), recipe.getResult(), recipe.getTemplate(), recipe.getBase(), recipe.getAddition(), recipe.willCopyNbt()); // Paper - Option to prevent NBT copy
          return ret;
      }
  
@@ -113,7 +113,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          ItemStack result = this.getResult();
  
 -        MinecraftServer.getServer().getRecipeManager().addRecipe(new RecipeHolder<>(CraftNamespacedKey.toMinecraft(this.getKey()), new net.minecraft.world.item.crafting.SmithingTransformRecipe(this.toNMS(this.getTemplate(), true), this.toNMS(this.getBase(), true), this.toNMS(this.getAddition(), true), CraftItemStack.asNMSCopy(result))));
-+        MinecraftServer.getServer().getRecipeManager().addRecipe(new RecipeHolder<>(CraftNamespacedKey.toMinecraft(this.getKey()), new net.minecraft.world.item.crafting.SmithingTransformRecipe(this.toNMS(this.getTemplate(), true), this.toNMS(this.getBase(), true), this.toNMS(this.getAddition(), true), CraftItemStack.asNMSCopy(result), this.willCopyNbt()))); // Paper
++        MinecraftServer.getServer().getRecipeManager().addRecipe(new RecipeHolder<>(CraftNamespacedKey.toMinecraft(this.getKey()), new net.minecraft.world.item.crafting.SmithingTransformRecipe(this.toNMS(this.getTemplate(), true), this.toNMS(this.getBase(), true), this.toNMS(this.getAddition(), true), CraftItemStack.asNMSCopy(result), this.willCopyNbt()))); // Paper - Option to prevent NBT copy
      }
  }
 diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftSmithingTrimRecipe.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftSmithingTrimRecipe.java
@@ -124,24 +124,24 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public CraftSmithingTrimRecipe(NamespacedKey key, RecipeChoice template, RecipeChoice base, RecipeChoice addition) {
          super(key, template, base, addition);
      }
-+    // Paper start
++    // Paper start - Option to prevent NBT copy
 +    public CraftSmithingTrimRecipe(NamespacedKey key, RecipeChoice template, RecipeChoice base, RecipeChoice addition, boolean copyNbt) {
 +        super(key, template, base, addition, copyNbt);
 +    }
-+    // Paper end
++    // Paper end - Option to prevent NBT copy
  
      public static CraftSmithingTrimRecipe fromBukkitRecipe(SmithingTrimRecipe recipe) {
          if (recipe instanceof CraftSmithingTrimRecipe) {
              return (CraftSmithingTrimRecipe) recipe;
          }
 -        CraftSmithingTrimRecipe ret = new CraftSmithingTrimRecipe(recipe.getKey(), recipe.getTemplate(), recipe.getBase(), recipe.getAddition());
-+        CraftSmithingTrimRecipe ret = new CraftSmithingTrimRecipe(recipe.getKey(), recipe.getTemplate(), recipe.getBase(), recipe.getAddition(), recipe.willCopyNbt()); // Paper
++        CraftSmithingTrimRecipe ret = new CraftSmithingTrimRecipe(recipe.getKey(), recipe.getTemplate(), recipe.getBase(), recipe.getAddition(), recipe.willCopyNbt()); // Paper - Option to prevent NBT copy
          return ret;
      }
  
      @Override
      public void addToCraftingManager() {
 -        MinecraftServer.getServer().getRecipeManager().addRecipe(new RecipeHolder<>(CraftNamespacedKey.toMinecraft(this.getKey()), new net.minecraft.world.item.crafting.SmithingTrimRecipe(this.toNMS(this.getTemplate(), true), this.toNMS(this.getBase(), true), this.toNMS(this.getAddition(), true))));
-+        MinecraftServer.getServer().getRecipeManager().addRecipe(new RecipeHolder<>(CraftNamespacedKey.toMinecraft(this.getKey()), new net.minecraft.world.item.crafting.SmithingTrimRecipe(this.toNMS(this.getTemplate(), true), this.toNMS(this.getBase(), true), this.toNMS(this.getAddition(), true), this.willCopyNbt()))); // Paper
++        MinecraftServer.getServer().getRecipeManager().addRecipe(new RecipeHolder<>(CraftNamespacedKey.toMinecraft(this.getKey()), new net.minecraft.world.item.crafting.SmithingTrimRecipe(this.toNMS(this.getTemplate(), true), this.toNMS(this.getBase(), true), this.toNMS(this.getAddition(), true), this.willCopyNbt()))); // Paper - Option to prevent NBT copy
      }
  }

patches/server/Prevent-AFK-kick-while-watching-end-credits.patch

@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Noah van der Aa <ndvdaa@gmail.com>
 Date: Sat, 24 Jul 2021 16:54:11 +0200
-Subject: [PATCH] Prevent AFK kick while watching end credits.
+Subject: [PATCH] Prevent AFK kick while watching end credits
 
 
 diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
@@ -13,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
  
 -        if (this.player.getLastActionTime() > 0L && this.server.getPlayerIdleTimeout() > 0 && Util.getMillis() - this.player.getLastActionTime() > (long) this.server.getPlayerIdleTimeout() * 1000L * 60L) {
-+        if (this.player.getLastActionTime() > 0L && this.server.getPlayerIdleTimeout() > 0 && Util.getMillis() - this.player.getLastActionTime() > (long) this.server.getPlayerIdleTimeout() * 1000L * 60L && !this.player.wonGame) { // Paper - Prevent AFK kick while watching end credits.
++        if (this.player.getLastActionTime() > 0L && this.server.getPlayerIdleTimeout() > 0 && Util.getMillis() - this.player.getLastActionTime() > (long) this.server.getPlayerIdleTimeout() * 1000L * 60L && !this.player.wonGame) { // Paper - Prevent AFK kick while watching end credits
              this.player.resetLastActionTime(); // CraftBukkit - SPIGOT-854
              this.disconnect(Component.translatable("multiplayer.disconnect.idling"), org.bukkit.event.player.PlayerKickEvent.Cause.IDLING); // Paper - kick event cause
          }

patches/server/Properly-handle-experience-dropping-on-block-break.patch

@@ -41,7 +41,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
          return true;
      }
-     // Paper end
+     // Paper end - Add BlockBreakBlockEvent
  
      public static void dropResources(BlockState state, Level world, BlockPos pos, @Nullable BlockEntity blockEntity, @Nullable Entity entity, ItemStack tool) {
 +    // Paper start - Properly handle xp dropping

patches/server/Rate-options-and-timings-for-sensors-and-behaviors.patch

@@ -38,7 +38,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    // Paper start - configurable behavior tick rate and timings
 +    private final String configKey;
 +    private final co.aikar.timings.Timing timing;
-+    // Paper end
++    // Paper end - configurable behavior tick rate and timings
  
      public Behavior(Map<MemoryModuleType<?>, MemoryStatus> requiredMemoryState) {
          this(requiredMemoryState, 60);
@@ -54,7 +54,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        }
 +        this.configKey = key.toLowerCase(java.util.Locale.ROOT);
 +        this.timing = co.aikar.timings.MinecraftTimings.getBehaviorTimings(configKey);
-+        // Paper end
++        // Paper end - configurable behavior tick rate and timings
      }
  
      @Override
@@ -62,12 +62,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public final boolean tryStart(ServerLevel world, E entity, long time) {
-+        // Paper start - behavior tick rate
++        // Paper start - configurable behavior tick rate and timings
 +        int tickRate = java.util.Objects.requireNonNullElse(world.paperConfig().tickRates.behavior.get(entity.getType(), this.configKey), -1);
 +        if (tickRate > -1 && time < this.endTimestamp + tickRate) {
 +            return false;
 +        }
-+        // Paper end
++        // Paper end - configurable behavior tick rate and timings
          if (this.hasRequiredMemories(entity) && this.checkExtraStartConditions(world, entity)) {
              this.status = Behavior.Status.RUNNING;
              int i = this.minDuration + world.getRandom().nextInt(this.maxDuration + 1 - this.minDuration);

patches/server/Use-correct-seed-on-api-world-load.patch

@@ -10,7 +10,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 @@ -0,0 +0,0 @@ public final class CraftServer implements Server {
  
-         // Paper - move down
+         // Paper - fix and optimise world upgrading; move down
  
 -        long j = BiomeManager.obfuscateSeed(creator.seed());
 +        long j = BiomeManager.obfuscateSeed(worlddata.worldGenOptions().seed()); // Paper - use world seed

patches/server/Use-getChunkIfLoadedImmediately-in-places.patch

@@ -16,7 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override public LevelChunk getChunkIfLoaded(int x, int z) { // Paper - this was added in world too but keeping here for NMS ABI
 -        return this.chunkSource.getChunk(x, z, false);
-+        return this.chunkSource.getChunkAtIfLoadedImmediately(x, z); // Paper
++        return this.chunkSource.getChunkAtIfLoadedImmediately(x, z); // Paper - Use getChunkIfLoadedImmediately
      }
  
      @Override
@@ -28,12 +28,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          return (CraftServer) Bukkit.getServer();
      }
  
-+    // Paper start
++    // Paper start - Use getChunkIfLoadedImmediately
 +    @Override
 +    public boolean hasChunk(int chunkX, int chunkZ) {
 +        return this.getChunkIfLoaded(chunkX, chunkZ) != null;
 +    }
-+    // Paper end
++    // Paper end - Use getChunkIfLoadedImmediately
 +
      public abstract ResourceKey<LevelStem> getTypeKey();
  
@@ -47,7 +47,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          for (int l1 = j; l1 <= i1; ++l1) {
              for (int i2 = l; i2 <= k1; ++i2) {
 -                LevelChunk chunk = this.level.getChunkSource().getChunkNow(l1, i2);
-+                LevelChunk chunk = (LevelChunk) this.level.getChunkIfLoadedImmediately(l1, i2); // Paper
++                LevelChunk chunk = (LevelChunk) this.level.getChunkIfLoadedImmediately(l1, i2); // Paper - Use getChunkIfLoadedImmediately
  
                  if (chunk != null) {
                      for (int j2 = k; j2 <= j1; ++j2) {

patches/server/add-per-world-spawn-limits.patch

@@ -3,7 +3,6 @@ From: chase <chasewhip20@gmail.com>
 Date: Wed, 2 Dec 2020 22:43:39 -0800
 Subject: [PATCH] add per world spawn limits
 
-Taken from #2982. Credit to Chasewhip8
 
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
@@ -19,7 +18,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                setSpawnLimit(spawnCategory, this.world.paperConfig().entities.spawning.spawnLimits.getInt(CraftSpawnCategory.toNMS(spawnCategory)));
 +            }
 +        }
-+        // Paper end
++        // Paper end - per world spawn limits
      }
  
      @Override