some more stuffs

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

@@ -54,3 +54,56 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +    // Paper end
  }
+diff --git a/src/main/java/org/bukkit/inventory/SmithingTransformRecipe.java b/src/main/java/org/bukkit/inventory/SmithingTransformRecipe.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/inventory/SmithingTransformRecipe.java
++++ b/src/main/java/org/bukkit/inventory/SmithingTransformRecipe.java
+@@ -0,0 +0,0 @@ public class SmithingTransformRecipe extends SmithingRecipe {
+         super(key, result, base, addition);
+         this.template = template;
+     }
++    // Paper start
++    /**
++     * Create a smithing recipe to produce the specified result ItemStack.
++     *
++     * @param key The unique recipe key
++     * @param result The item you want the recipe to create.
++     * @param template The template item.
++     * @param base The base ingredient
++     * @param addition The addition ingredient
++     * @param copyNbt whether to copy the nbt from the input base item to the output
++     */
++    public SmithingTransformRecipe(@NotNull NamespacedKey key, @NotNull ItemStack result, @NotNull RecipeChoice template, @NotNull RecipeChoice base, @NotNull RecipeChoice addition, boolean copyNbt) {
++        super(key, result, base, addition, copyNbt);
++        this.template = template;
++    }
++    // Paper end
+ 
+     /**
+      * Get the template recipe item.
+diff --git a/src/main/java/org/bukkit/inventory/SmithingTrimRecipe.java b/src/main/java/org/bukkit/inventory/SmithingTrimRecipe.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/inventory/SmithingTrimRecipe.java
++++ b/src/main/java/org/bukkit/inventory/SmithingTrimRecipe.java
+@@ -0,0 +0,0 @@ public class SmithingTrimRecipe extends SmithingRecipe implements ComplexRecipe
+         super(key, new ItemStack(Material.AIR), base, addition);
+         this.template = template;
+     }
++    // Paper start
++    /**
++     * Create a smithing recipe to produce the specified result ItemStack.
++     *
++     * @param key The unique recipe key
++     * @param template The template item.
++     * @param base The base ingredient
++     * @param addition The addition ingredient
++     * @param copyNbt whether to copy the nbt from the input base item to the output
++     */
++    public SmithingTrimRecipe(@NotNull NamespacedKey key, @NotNull RecipeChoice template, @NotNull RecipeChoice base, @NotNull RecipeChoice addition, boolean copyNbt) {
++        super(key, new ItemStack(Material.AIR), base, addition, copyNbt);
++        this.template = template;
++    }
++    // Paper end
+ 
+     /**
+      * Get the template recipe item.

patches/server/Add-BlockBreakBlockEvent.patch

@@ -30,7 +30,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +    // Paper end
  
-     public static void dropResources(BlockState state, Level world, BlockPos pos, @Nullable BlockEntity blockEntity, Entity entity, ItemStack tool) {
+     public static void dropResources(BlockState state, Level world, BlockPos pos, @Nullable BlockEntity blockEntity, @Nullable Entity entity, ItemStack tool) {
          if (world instanceof ServerLevel) {
 diff --git a/src/main/java/net/minecraft/world/level/block/piston/PistonBaseBlock.java b/src/main/java/net/minecraft/world/level/block/piston/PistonBaseBlock.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
@@ -65,7 +65,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    protected void beforeDestroyingBlock(LevelAccessor world, BlockPos pos, BlockState state, BlockPos source) { beforeDestroyingBlock(world, pos, state); } // Paper - add source parameter
      protected abstract void beforeDestroyingBlock(LevelAccessor world, BlockPos pos, BlockState state);
  
-     private static short getCacheKey(BlockPos blockposition, BlockPos blockposition1) {
+     private static short getCacheKey(BlockPos from, BlockPos to) {
 diff --git a/src/main/java/net/minecraft/world/level/material/WaterFluid.java b/src/main/java/net/minecraft/world/level/material/WaterFluid.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/material/WaterFluid.java

patches/server/Add-ElderGuardianAppearanceEvent.patch

@@ -41,8 +41,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          super.customServerAiStep();
          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); // 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
  
              list.forEach((entityplayer) -> {
                  entityplayer.connection.send(new ClientboundGameEventPacket(ClientboundGameEventPacket.GUARDIAN_ELDER_EFFECT, this.isSilent() ? 0.0F : 1.0F));

patches/server/Add-PlayerSetSpawnEvent.patch

@@ -41,9 +41,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              } else if (this.bedBlocked(blockposition, enumdirection)) {
                  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, 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 - PlayerSetSpawnEvent
-                 if (this.level.isDay()) {
+                 if (this.level().isDay()) {
                      return Either.left(Player.BedSleepingProblem.NOT_POSSIBLE_NOW);
                  } else {
 @@ -0,0 +0,0 @@ public class ServerPlayer extends Player {

patches/server/Add-a-bunch-of-missing-forceDrop-toggles.patch

@@ -25,7 +25,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class Panda extends Animal {
          }
  
-         if (!this.level.isClientSide() && this.random.nextInt(700) == 0 && this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
+         if (!this.level().isClientSide() && this.random.nextInt(700) == 0 && this.level().getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
 +            this.forceDrops = true; // Paper
              this.spawnAtLocation((ItemLike) Items.SLIME_BALL);
 +            this.forceDrops = false; // Paper

patches/server/Added-EntityDamageItemEvent.patch

@@ -56,7 +56,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              j = this.getDamageValue() + amount;
 @@ -0,0 +0,0 @@ public final class ItemStack {
      public <T extends LivingEntity> void hurtAndBreak(int amount, T entity, Consumer<T> breakCallback) {
-         if (!entity.level.isClientSide && (!(entity instanceof net.minecraft.world.entity.player.Player) || !((net.minecraft.world.entity.player.Player) entity).getAbilities().instabuild)) {
+         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

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
-         List<Piglin> list = player.level.getEntitiesOfClass(Piglin.class, player.getBoundingBox().inflate(16.0D));
+         List<Piglin> list = player.level().getEntitiesOfClass(Piglin.class, player.getBoundingBox().inflate(16.0D));
  
          list.stream().filter(PiglinAi::isIdle).filter((entitypiglin) -> {

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

@@ -30,6 +30,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            itemstack.setCount(0);
 +            itemstack = tmp;
 +            // Paper end
-             ItemEntity entityitem = new ItemEntity(this.level, this.getX(), d0, this.getZ(), itemstack);
+             ItemEntity entityitem = new ItemEntity(this.level(), this.getX(), d0, this.getZ(), itemstack);
  
              entityitem.setPickUpDelay(40);

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

@@ -61,33 +61,25 @@ diff --git a/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntit
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
 +++ b/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
-@@ -0,0 +0,0 @@ public class SignBlockEntity extends BlockEntity implements CommandSource { // C
-     private boolean renderMessagedFiltered;
-     private DyeColor color;
-     private boolean hasGlowingText;
-+    private static final org.apache.logging.log4j.Logger LOGGER = org.apache.logging.log4j.LogManager.getLogger();
- 
-     public SignBlockEntity(BlockPos pos, BlockState state) {
-         super(BlockEntityType.SIGN, pos, state);
 @@ -0,0 +0,0 @@ public class SignBlockEntity extends BlockEntity implements CommandSource { // C
              ClickEvent chatclickable = chatmodifier.getClickEvent();
  
              if (chatclickable != null && chatclickable.getAction() == ClickEvent.Action.RUN_COMMAND) {
--                player.getServer().getCommands().performPrefixedCommand(this.createCommandSourceStack(player), chatclickable.getValue());
+-                player.getServer().getCommands().performPrefixedCommand(this.createCommandSourceStack(player, world, pos), chatclickable.getValue());
 +                // Paper start
 +                String command = chatclickable.getValue().startsWith("/") ? chatclickable.getValue() : "/" + chatclickable.getValue();
 +                if (org.spigotmc.SpigotConfig.logCommands)  {
 +                    LOGGER.info("{} issued server command: {}", player.getScoreboardName(), command);
 +                }
-+                io.papermc.paper.event.player.PlayerSignCommandPreprocessEvent event = new io.papermc.paper.event.player.PlayerSignCommandPreprocessEvent(player.getBukkitEntity(), command, new org.bukkit.craftbukkit.util.LazyPlayerSet(player.getServer()), (org.bukkit.block.Sign) io.papermc.paper.util.MCUtil.toBukkitBlock(this.level, this.worldPosition).getState());
++                io.papermc.paper.event.player.PlayerSignCommandPreprocessEvent event = new io.papermc.paper.event.player.PlayerSignCommandPreprocessEvent((org.bukkit.entity.Player) player.getBukkitEntity(), command, new org.bukkit.craftbukkit.util.LazyPlayerSet(player.getServer()), (org.bukkit.block.Sign) io.papermc.paper.util.MCUtil.toBukkitBlock(this.level, this.worldPosition).getState());
 +                if (!event.callEvent()) {
 +                    return false;
 +                }
-+                player.getServer().getCommands().performPrefixedCommand(this.createCommandSourceStack(((org.bukkit.craftbukkit.entity.CraftPlayer) event.getPlayer()).getHandle()), event.getMessage());
++                player.getServer().getCommands().performPrefixedCommand(this.createCommandSourceStack(((org.bukkit.craftbukkit.entity.CraftPlayer) event.getPlayer()).getHandle(), world, pos), event.getMessage());
 +                // Paper end
+                 flag1 = true;
              }
          }
- 
 @@ -0,0 +0,0 @@ public class SignBlockEntity extends BlockEntity implements CommandSource { // C
          String s = player == null ? "Sign" : player.getName().getString();
          Object object = player == null ? Component.literal("Sign") : player.getDisplayName();
@@ -96,7 +88,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        CommandSource commandSource = this.level.paperConfig().misc.showSignClickCommandFailureMsgsToPlayer ? new io.papermc.paper.commands.DelegatingCommandSource(this) {
 +            @Override
 +            public void sendSystemMessage(Component message) {
-+                player.sendSystemMessage(message);
++                if (player != null) {
++                    player.sendSystemMessage(message);
++                }
 +            }
 +
 +            @Override
@@ -106,11 +100,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        } : this;
 +        // Paper end
          // CraftBukkit - this
--        return new CommandSourceStack(this, Vec3.atCenterOf(this.worldPosition), Vec2.ZERO, (ServerLevel) this.level, 2, s, (Component) object, this.level.getServer(), player);
+-        return new CommandSourceStack(this, Vec3.atCenterOf(pos), Vec2.ZERO, (ServerLevel) world, 2, s, (Component) object, world.getServer(), player);
-+        return new CommandSourceStack(commandSource, Vec3.atCenterOf(this.worldPosition), Vec2.ZERO, (ServerLevel) this.level, 2, s, (Component) object, this.level.getServer(), player); // Paper
++        return new CommandSourceStack(commandSource, Vec3.atCenterOf(pos), Vec2.ZERO, (ServerLevel) world, 2, s, (Component) object, world.getServer(), player); // Paper
      }
  
-     public DyeColor getColor() {
+     @Override
 diff --git a/src/main/java/org/bukkit/craftbukkit/command/BukkitCommandWrapper.java b/src/main/java/org/bukkit/craftbukkit/command/BukkitCommandWrapper.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/command/BukkitCommandWrapper.java

patches/server/Fix-dangerous-end-portal-logic.patch

@@ -15,9 +15,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
 @@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
-         return chunkMap.playerEntityTrackerTrackMaps[type.ordinal()].getObjectsInRange(MCUtil.getCoordinateKey(this));
      }
-     // Paper end - optimise entity tracking
+     // Paper end
+ 
 +    // Paper start - make end portalling safe
 +    public BlockPos portalBlock;
 +    public ServerLevel portalWorld;
@@ -48,9 +48,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this.teleportTo(worldserver, null);
 +    }
 +    // Paper end - make end portalling safe
- 
++
      public Entity(EntityType<?> type, Level world) {
          this.id = Entity.ENTITY_COUNTER.incrementAndGet();
+         this.passengers = ImmutableList.of();
 @@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
              }
  

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

@@ -33,7 +33,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            if (showParticles) { // Paper
              int i = potionregistry.hasInstantEffects() ? 2007 : 2002;
  
-             this.level.levelEvent(i, this.blockPosition(), PotionUtils.getColor(itemstack));
+             this.level().levelEvent(i, this.blockPosition(), PotionUtils.getColor(itemstack));
 +            } // Paper
              this.discard();
          }
@@ -43,9 +43,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    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
          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);
+-        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
-+        List<net.minecraft.world.entity.LivingEntity> list = this.level.getEntitiesOfClass(net.minecraft.world.entity.LivingEntity.class, axisalignedbb, ThrownPotion.APPLY_WATER_GET_ENTITIES_PREDICATE);
++        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<>();
 +        java.util.Set<LivingEntity> extinguish = new java.util.HashSet<>();
@@ -71,7 +71,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
          }
  
--        List<Axolotl> list1 = this.level.getEntitiesOfClass(Axolotl.class, axisalignedbb);
+-        List<Axolotl> list1 = this.level().getEntitiesOfClass(Axolotl.class, axisalignedbb);
 -        Iterator iterator1 = list1.iterator();
 -
 -        while (iterator1.hasNext()) {
@@ -102,7 +102,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -    private void applySplash(List<MobEffectInstance> statusEffects, @Nullable Entity entity) {
 +    private boolean applySplash(List<MobEffectInstance> statusEffects, @Nullable Entity entity) { // Paper
          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);
+         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
 @@ -0,0 +0,0 @@ public class ThrownPotion extends ThrowableItemProjectile implements ItemSupplie
                      if (d0 < 16.0D) {
@@ -122,7 +122,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 -    private void makeAreaOfEffectCloud(ItemStack stack, Potion potion) {
 +    private boolean makeAreaOfEffectCloud(ItemStack stack, Potion potion) { // Paper
-         AreaEffectCloud entityareaeffectcloud = new AreaEffectCloud(this.level, this.getX(), this.getY(), this.getZ());
+         AreaEffectCloud entityareaeffectcloud = new AreaEffectCloud(this.level(), this.getX(), this.getY(), this.getZ());
          Entity entity = this.getOwner();
  
 @@ -0,0 +0,0 @@ public class ThrownPotion extends ThrowableItemProjectile implements ItemSupplie
@@ -144,7 +144,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          org.bukkit.event.entity.LingeringPotionSplashEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callLingeringPotionSplashEvent(this, entityareaeffectcloud);
 -        if (!(event.isCancelled() || entityareaeffectcloud.isRemoved())) {
 +        if (!(event.isCancelled() || entityareaeffectcloud.isRemoved() || (noEffects && entityareaeffectcloud.effects.isEmpty() && entityareaeffectcloud.getPotion().getEffects().isEmpty()))) { // Paper - don't spawn area effect cloud if the effects were empty and not changed during the event handling
-             this.level.addFreshEntity(entityareaeffectcloud);
+             this.level().addFreshEntity(entityareaeffectcloud);
          } else {
              entityareaeffectcloud.discard();
          }

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

@@ -15,7 +15,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -    public String kickLeaveMessage = null; // SPIGOT-3034: Forward leave message to PlayerQuitEvent
      // CraftBukkit end
      public boolean isRealPlayer; // Paper
-     public double lastEntitySpawnRadiusSquared; // Paper - optimise isOutsideRange, this field is in blocks
+     public final com.destroystokyo.paper.util.misc.PooledLinkedHashSets.PooledObjectLinkedOpenHashSet<ServerPlayer> cachedSingleHashSet; // Paper
 diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
@@ -65,13 +65,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public abstract class PlayerList {
      }
  
-     public net.kyori.adventure.text.Component remove(ServerPlayer entityplayer) { // Paper - return Component
+     public net.kyori.adventure.text.Component remove(ServerPlayer entityplayer) { // CraftBukkit - return string // Paper - return Component
 +        // Paper start
 +        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() : PaperAdventure.asAdventure(entityplayer.getDisplayName())));
 +    }
 +    public net.kyori.adventure.text.Component remove(ServerPlayer entityplayer, net.kyori.adventure.text.Component leaveMessage) {
 +        // Paper end
-         ServerLevel worldserver = entityplayer.getLevel();
+         ServerLevel worldserver = entityplayer.serverLevel();
  
          entityplayer.awardStat(Stats.LEAVE_GAME);
 @@ -0,0 +0,0 @@ public abstract class PlayerList {

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

@@ -12,9 +12,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              Vec3 vec3d = new Vec3(this.getX(), this.getEyeY(), this.getZ());
              Vec3 vec3d1 = new Vec3(entity.getX(), entity.getEyeY(), entity.getZ());
  
--            return vec3d1.distanceTo(vec3d) > 128.0D ? false : this.level.clip(new ClipContext(vec3d, vec3d1, ClipContext.Block.COLLIDER, ClipContext.Fluid.NONE, this)).getType() == HitResult.Type.MISS;
+-            return vec3d1.distanceTo(vec3d) > 128.0D ? false : this.level().clip(new ClipContext(vec3d, vec3d1, ClipContext.Block.COLLIDER, ClipContext.Fluid.NONE, this)).getType() == HitResult.Type.MISS;
 +            // Paper - diff on change - used in CraftLivingEntity#hasLineOfSight(Location) and CraftWorld#lineOfSightExists
-+            return vec3d1.distanceToSqr(vec3d) > 128D * 128D ? false : this.level.clip(new ClipContext(vec3d, vec3d1, ClipContext.Block.COLLIDER, ClipContext.Fluid.NONE, this)).getType() == HitResult.Type.MISS; // Paper - use distanceToSqr
++            return vec3d1.distanceToSqr(vec3d) > 128D * 128D ? false : this.level().clip(new ClipContext(vec3d, vec3d1, ClipContext.Block.COLLIDER, ClipContext.Fluid.NONE, this)).getType() == HitResult.Type.MISS;
          }
      }
  
@@ -60,12 +60,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    // Paper start
 +    @Override
 +    public boolean hasLineOfSight(Location loc) {
-+        if (this.getHandle().level != ((CraftWorld) loc.getWorld()).getHandle()) return false;
++        if (this.getHandle().level() != ((CraftWorld) loc.getWorld()).getHandle()) return false;
 +        Vec3 vec3d = new Vec3(this.getHandle().getX(), this.getHandle().getEyeY(), this.getHandle().getZ());
 +        Vec3 vec3d1 = new Vec3(loc.getX(), loc.getY(), loc.getZ());
 +        if (vec3d1.distanceToSqr(vec3d) > 128D * 128D) return false; //Return early if the distance is greater than 128 blocks
 +
-+        return this.getHandle().level.clip(new ClipContext(vec3d, vec3d1, ClipContext.Block.COLLIDER, ClipContext.Fluid.NONE, this.getHandle())).getType() == HitResult.Type.MISS;
++        return this.getHandle().level().clip(new ClipContext(vec3d, vec3d1, ClipContext.Block.COLLIDER, ClipContext.Fluid.NONE, this.getHandle())).getType() == HitResult.Type.MISS;
 +    }
 +    // Paper end
 +

patches/server/Make-EntityUnleashEvent-cancellable.patch

@@ -11,8 +11,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -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(), UnleashReason.UNKNOWN, true);
+             EntityUnleashEvent event = new EntityUnleashEvent(this.getBukkitEntity(), EntityUnleashEvent.UnleashReason.UNKNOWN, true);
--            this.level.getCraftServer().getPluginManager().callEvent(event); // CraftBukkit
+-            this.level().getCraftServer().getPluginManager().callEvent(event); // CraftBukkit
 +            if (!event.callEvent()) { return flag1; }
              this.dropLeash(true, event.isDropLeash());
              // Paper end
@@ -22,20 +22,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- 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
+                 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
+-                    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
+             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
+-                this.level().getCraftServer().getPluginManager().callEvent(event); // CraftBukkit
-+                if (!event.callEvent()) return;
++                if (!event.callEvent()) { return; }
                  this.dropLeash(true, event.isDropLeash());
                  // Paper end
                  this.goalSelector.disableControlFlag(Goal.Flag.MOVE);

patches/server/Missing-Entity-Behavior-API.patch

@@ -154,8 +154,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public void aiStep() {
          super.aiStep();
--        if (!this.level.isClientSide) {
+-        if (!this.level().isClientSide) {
-+        if (!this.level.isClientSide && !this.ageLocked) { // Paper
++        if (!this.level().isClientSide && !this.ageLocked) { // Paper
              this.setAge(this.age + 1);
          }
  
@@ -325,10 +325,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          this.getEntityData().set(ZombieVillager.DATA_CONVERTING_ID, true);
 @@ -0,0 +0,0 @@ public class ZombieVillager extends Zombie implements VillagerDataHolder {
          this.removeEffect(MobEffects.WEAKNESS, org.bukkit.event.entity.EntityPotionEffectEvent.Cause.CONVERSION);
-         this.addEffect(new MobEffectInstance(MobEffects.DAMAGE_BOOST, delay, Math.min(this.level.getDifficulty().getId() - 1, 0)), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.CONVERSION);
+         this.addEffect(new MobEffectInstance(MobEffects.DAMAGE_BOOST, delay, Math.min(this.level().getDifficulty().getId() - 1, 0)), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.CONVERSION);
          // CraftBukkit end
--        this.level.broadcastEntityEvent(this, (byte) 16);
+-        this.level().broadcastEntityEvent(this, (byte) 16);
-+        if (broadcastEntityEvent) this.level.broadcastEntityEvent(this, (byte) 16); // Paper - missing entity behaviour api - converting without entity event
++        if (broadcastEntityEvent) this.level().broadcastEntityEvent(this, (byte) 16); // Paper - missing entity behaviour api - converting without entity event
      }
  
      @Override

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

@@ -43,8 +43,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          return () -> {
              return this.getIndirectPassengersStream().iterator();
          };
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+     }
-     // Paper end - rewrite chunk system
  
      public boolean hasExactlyOnePlayerPassenger() {
 +        if (this.passengers.isEmpty()) { return false; } // Paper

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

@@ -0,0 +1,147 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 26 Sep 2021 12:57:28 -0700
+Subject: [PATCH] Option to prevent NBT copy in smithing recipes
+
+
+diff --git a/src/main/java/net/minecraft/world/item/crafting/SmithingTransformRecipe.java b/src/main/java/net/minecraft/world/item/crafting/SmithingTransformRecipe.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/item/crafting/SmithingTransformRecipe.java
++++ b/src/main/java/net/minecraft/world/item/crafting/SmithingTransformRecipe.java
+@@ -0,0 +0,0 @@ public class SmithingTransformRecipe implements SmithingRecipe {
+     final Ingredient base;
+     final Ingredient addition;
+     final ItemStack result;
++    final boolean copyNBT; // Paper
+ 
+     public SmithingTransformRecipe(ResourceLocation id, Ingredient template, Ingredient base, Ingredient addition, ItemStack result) {
++        // Paper start
++        this(id, template, base, addition, result, true);
++    }
++    public SmithingTransformRecipe(ResourceLocation id, Ingredient template, Ingredient base, Ingredient addition, ItemStack result, boolean copyNBT) {
++        this.copyNBT = copyNBT;
++        // Paper end
+         this.id = id;
+         this.template = template;
+         this.base = base;
+@@ -0,0 +0,0 @@ public class SmithingTransformRecipe implements SmithingRecipe {
+     @Override
+     public ItemStack assemble(Container inventory, RegistryAccess registryManager) {
+         ItemStack itemstack = this.result.copy();
++        if (this.copyNBT) { // Paper - copy nbt conditionally
+         CompoundTag nbttagcompound = inventory.getItem(1).getTag();
+ 
+         if (nbttagcompound != null) {
+             itemstack.setTag(nbttagcompound.copy());
+         }
++        } // Paper
+ 
+         return itemstack;
+     }
+@@ -0,0 +0,0 @@ public class SmithingTransformRecipe implements SmithingRecipe {
+     public Recipe toBukkitRecipe() {
+         CraftItemStack result = CraftItemStack.asCraftMirror(this.result);
+ 
+-        CraftSmithingTransformRecipe recipe = new CraftSmithingTransformRecipe(CraftNamespacedKey.fromMinecraft(this.id), result, CraftRecipe.toBukkit(this.template), CraftRecipe.toBukkit(this.base), CraftRecipe.toBukkit(this.addition));
++        CraftSmithingTransformRecipe recipe = new CraftSmithingTransformRecipe(CraftNamespacedKey.fromMinecraft(this.id), result, CraftRecipe.toBukkit(this.template), CraftRecipe.toBukkit(this.base), CraftRecipe.toBukkit(this.addition), this.copyNBT); // Paper
+ 
+         return recipe;
+     }
+diff --git a/src/main/java/net/minecraft/world/item/crafting/SmithingTrimRecipe.java b/src/main/java/net/minecraft/world/item/crafting/SmithingTrimRecipe.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/item/crafting/SmithingTrimRecipe.java
++++ b/src/main/java/net/minecraft/world/item/crafting/SmithingTrimRecipe.java
+@@ -0,0 +0,0 @@ public class SmithingTrimRecipe implements SmithingRecipe {
+     final Ingredient template;
+     final Ingredient base;
+     final Ingredient addition;
++    final boolean copyNbt; // Paper
+ 
+     public SmithingTrimRecipe(ResourceLocation id, Ingredient template, Ingredient base, Ingredient addition) {
++        // Paper start
++        this(id, template, base, addition, true);
++    }
++    public SmithingTrimRecipe(ResourceLocation id, Ingredient template, Ingredient base, Ingredient addition, boolean copyNbt) {
++        this.copyNbt = copyNbt;
++        // Paper end
+         this.id = id;
+         this.template = template;
+         this.base = base;
+@@ -0,0 +0,0 @@ public class SmithingTrimRecipe implements SmithingRecipe {
+                     return ItemStack.EMPTY;
+                 }
+ 
+-                ItemStack itemstack1 = itemstack.copy();
++                ItemStack itemstack1 = this.copyNbt ? itemstack.copy() : new ItemStack(itemstack.getItem(), itemstack.getCount()); // Paper
+ 
+                 itemstack1.setCount(1);
+                 ArmorTrim armortrim = new ArmorTrim((Holder) optional.get(), (Holder) optional1.get());
+@@ -0,0 +0,0 @@ public class SmithingTrimRecipe implements SmithingRecipe {
+     // CraftBukkit start
+     @Override
+     public Recipe toBukkitRecipe() {
+-        return new CraftSmithingTrimRecipe(CraftNamespacedKey.fromMinecraft(this.id), CraftRecipe.toBukkit(this.template), CraftRecipe.toBukkit(this.base), CraftRecipe.toBukkit(this.addition));
++        return new CraftSmithingTrimRecipe(CraftNamespacedKey.fromMinecraft(this.id), CraftRecipe.toBukkit(this.template), CraftRecipe.toBukkit(this.base), CraftRecipe.toBukkit(this.addition), this.copyNbt); // Paper
+     }
+     // CraftBukkit end
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftSmithingTransformRecipe.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftSmithingTransformRecipe.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftSmithingTransformRecipe.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftSmithingTransformRecipe.java
+@@ -0,0 +0,0 @@ public class CraftSmithingTransformRecipe extends SmithingTransformRecipe implem
+     public CraftSmithingTransformRecipe(NamespacedKey key, ItemStack result, RecipeChoice template, RecipeChoice base, RecipeChoice addition) {
+         super(key, result, template, base, addition);
+     }
++    // Paper start
++    public CraftSmithingTransformRecipe(NamespacedKey key, ItemStack result, RecipeChoice template, RecipeChoice base, RecipeChoice addition, boolean copyNbt) {
++        super(key, result, template, base, addition, copyNbt);
++    }
++    // Paper end
+ 
+     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
+         return ret;
+     }
+ 
+@@ -0,0 +0,0 @@ public class CraftSmithingTransformRecipe extends SmithingTransformRecipe implem
+     public void addToCraftingManager() {
+         ItemStack result = this.getResult();
+ 
+-        MinecraftServer.getServer().getRecipeManager().addRecipe(new net.minecraft.world.item.crafting.SmithingTransformRecipe(CraftNamespacedKey.toMinecraft(this.getKey()), toNMS(this.getTemplate(), true), toNMS(this.getBase(), true), toNMS(this.getAddition(), true), CraftItemStack.asNMSCopy(result)));
++        MinecraftServer.getServer().getRecipeManager().addRecipe(new net.minecraft.world.item.crafting.SmithingTransformRecipe(CraftNamespacedKey.toMinecraft(this.getKey()), toNMS(this.getTemplate(), true), toNMS(this.getBase(), true), toNMS(this.getAddition(), true), CraftItemStack.asNMSCopy(result), this.willCopyNbt())); // Paper
+     }
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftSmithingTrimRecipe.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftSmithingTrimRecipe.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftSmithingTrimRecipe.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftSmithingTrimRecipe.java
+@@ -0,0 +0,0 @@ public class CraftSmithingTrimRecipe extends SmithingTrimRecipe implements Craft
+     public CraftSmithingTrimRecipe(NamespacedKey key, RecipeChoice template, RecipeChoice base, RecipeChoice addition) {
+         super(key, template, base, addition);
+     }
++    // Paper start
++    public CraftSmithingTrimRecipe(NamespacedKey key, RecipeChoice template, RecipeChoice base, RecipeChoice addition, boolean copyNbt) {
++        super(key, template, base, addition, copyNbt);
++    }
++    // Paper end
+ 
+     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
+         return ret;
+     }
+ 
+     @Override
+     public void addToCraftingManager() {
+-        MinecraftServer.getServer().getRecipeManager().addRecipe(new net.minecraft.world.item.crafting.SmithingTrimRecipe(CraftNamespacedKey.toMinecraft(this.getKey()), toNMS(this.getTemplate(), true), toNMS(this.getBase(), true), toNMS(this.getAddition(), true)));
++        MinecraftServer.getServer().getRecipeManager().addRecipe(new net.minecraft.world.item.crafting.SmithingTrimRecipe(CraftNamespacedKey.toMinecraft(this.getKey()), toNMS(this.getTemplate(), true), toNMS(this.getBase(), true), toNMS(this.getAddition(), true), this.willCopyNbt())); // Paper
+     }
+ }

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

@@ -12,8 +12,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              --this.dropSpamTickCount;
          }
  
--        if (this.player.getLastActionTime() > 0L && this.server.getPlayerIdleTimeout() > 0 && Util.getMillis() - this.player.getLastActionTime() > (long) (this.server.getPlayerIdleTimeout() * 1000 * 60)) {
+-        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() * 1000 * 60) && !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/Use-getChunkIfLoadedImmediately-in-places.patch

@@ -37,7 +37,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
      public abstract ResourceKey<LevelStem> getTypeKey();
  
-     protected Level(WritableLevelData worlddatamutable, ResourceKey<Level> resourcekey, RegistryAccess iregistrycustom, Holder<DimensionType> holder, Supplier<ProfilerFiller> supplier, boolean flag, boolean flag1, long i, int j, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env, java.util.function.Function<org.spigotmc.SpigotWorldConfig, io.papermc.paper.configuration.WorldConfiguration> paperWorldConfigCreator, java.util.concurrent.Executor executor) { // Paper - Async-Anti-Xray - Pass executor
+     protected Level(WritableLevelData worlddatamutable, ResourceKey<Level> resourcekey, RegistryAccess iregistrycustom, Holder<DimensionType> holder, Supplier<ProfilerFiller> supplier, boolean flag, boolean flag1, long i, int j, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env, java.util.function.Function<org.spigotmc.SpigotWorldConfig, io.papermc.paper.configuration.WorldConfiguration> paperWorldConfigCreator) { // Paper
 diff --git a/src/main/java/net/minecraft/world/level/gameevent/GameEventDispatcher.java b/src/main/java/net/minecraft/world/level/gameevent/GameEventDispatcher.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/gameevent/GameEventDispatcher.java

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

@@ -1,70 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Professor Bloodstone <git@bloodstone.dev>
-Date: Fri, 23 Jul 2021 02:32:04 +0200
-Subject: [PATCH] Allow skipping writing of comments to server.properties
-
-Makes less git noise, as it won't update the date every single time
-
-Use -DPaper.skipServerPropertiesComments=true flag to disable writing it
-
-diff --git a/src/main/java/net/minecraft/server/dedicated/Settings.java b/src/main/java/net/minecraft/server/dedicated/Settings.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/dedicated/Settings.java
-+++ b/src/main/java/net/minecraft/server/dedicated/Settings.java
-@@ -0,0 +0,0 @@ public abstract class Settings<T extends Settings<T>> {
- 
-     private static final Logger LOGGER = LogUtils.getLogger();
-     public final Properties properties;
-+    private static final boolean skipComments = Boolean.getBoolean("Paper.skipServerPropertiesComments"); // Paper - allow skipping server.properties comments
-     // CraftBukkit start
-     private OptionSet options = null;
- 
-@@ -0,0 +0,0 @@ public abstract class Settings<T extends Settings<T>> {
-             }
-             // CraftBukkit end
-             OutputStream outputstream = Files.newOutputStream(path);
-+            // Paper start - disable writing comments to properties file
-+            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
-+                private boolean isComment = false; // Are we writing comment currently?
-+
-+                @Override
-+                public void write(@org.jetbrains.annotations.NotNull byte[] b) throws IOException {
-+                    this.write(b, 0, b.length);
-+                }
-+
-+                @Override
-+                public void write(@org.jetbrains.annotations.NotNull byte[] bbuf, int off, int len) throws IOException {
-+                    int latest_offset = off; // The latest offset, updated when comment ends
-+                    for (int index = off; index < off + len; ++index ) {
-+                        byte c = bbuf[index];
-+                        boolean isNewline = (c == '\n' || c == '\r');
-+                        if (isNewline && isComment) {
-+                            // Comment has ended
-+                            isComment = false;
-+                            latest_offset = index+1;
-+                        }
-+                        if (c == '#' && isRightAfterNewline) {
-+                            isComment = true;
-+                            if (index != latest_offset) {
-+                                // We got some non-comment data earlier
-+                                super.write(bbuf, latest_offset, index-latest_offset);
-+                            }
-+                        }
-+                        isRightAfterNewline = isNewline; // Store for next iteration
-+
-+                    }
-+                    if (latest_offset < off+len && !isComment) {
-+                        // We have some unwritten data, that isn't part of a comment
-+                        super.write(bbuf, latest_offset, (off + len) - latest_offset);
-+                    }
-+                }
-+            };
-+            // Paper end
- 
-             try {
--                this.properties.store(outputstream, "Minecraft server properties");
-+                this.properties.store(bufferedOutputStream, "Minecraft server properties"); // Paper - use bufferedOutputStream
-             } catch (Throwable throwable) {
-                 if (outputstream != null) {
-                     try {

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

@@ -1,84 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Sun, 26 Sep 2021 12:57:28 -0700
-Subject: [PATCH] Option to prevent NBT copy in smithing recipes
-
-
-diff --git a/src/main/java/net/minecraft/world/item/crafting/LegacyUpgradeRecipe.java b/src/main/java/net/minecraft/world/item/crafting/LegacyUpgradeRecipe.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/crafting/LegacyUpgradeRecipe.java
-+++ b/src/main/java/net/minecraft/world/item/crafting/LegacyUpgradeRecipe.java
-@@ -0,0 +0,0 @@ public class LegacyUpgradeRecipe implements SmithingRecipe {
-     final Ingredient addition;
-     final ItemStack result;
-     private final ResourceLocation id;
-+    final boolean copyNBT; // Paper
- 
-     public LegacyUpgradeRecipe(ResourceLocation id, Ingredient base, Ingredient addition, ItemStack result) {
-+        // Paper start
-+        this(id, base, addition, result, true);
-+    }
-+    public LegacyUpgradeRecipe(ResourceLocation id, Ingredient base, Ingredient addition, ItemStack result, boolean copyNBT) {
-+        this.copyNBT = copyNBT;
-+        // Paper end
-         this.id = id;
-         this.base = base;
-         this.addition = addition;
-@@ -0,0 +0,0 @@ public class LegacyUpgradeRecipe implements SmithingRecipe {
-     @Override
-     public ItemStack assemble(Container inventory, RegistryAccess registryManager) {
-         ItemStack itemstack = this.result.copy();
-+        if (this.copyNBT) { // Paper - copy nbt conditionally
-         CompoundTag nbttagcompound = inventory.getItem(0).getTag();
- 
-         if (nbttagcompound != null) {
-             itemstack.setTag(nbttagcompound.copy());
-         }
-+        } // Paper
- 
-         return itemstack;
-     }
-@@ -0,0 +0,0 @@ public class LegacyUpgradeRecipe implements SmithingRecipe {
-     public Recipe toBukkitRecipe() {
-         CraftItemStack result = CraftItemStack.asCraftMirror(this.result);
- 
--        CraftSmithingRecipe recipe = new CraftSmithingRecipe(CraftNamespacedKey.fromMinecraft(this.id), result, CraftRecipe.toBukkit(this.base), CraftRecipe.toBukkit(this.addition));
-+        CraftSmithingRecipe recipe = new CraftSmithingRecipe(CraftNamespacedKey.fromMinecraft(this.id), result, CraftRecipe.toBukkit(this.base), CraftRecipe.toBukkit(this.addition), this.copyNBT); // Paper
- 
-         return recipe;
-     }
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftSmithingRecipe.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftSmithingRecipe.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftSmithingRecipe.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftSmithingRecipe.java
-@@ -0,0 +0,0 @@ import org.bukkit.inventory.RecipeChoice;
- import org.bukkit.inventory.SmithingRecipe;
- 
- public class CraftSmithingRecipe extends SmithingRecipe implements CraftRecipe {
-+    @Deprecated // Paper
-     public CraftSmithingRecipe(NamespacedKey key, ItemStack result, RecipeChoice base, RecipeChoice addition) {
-         super(key, result, base, addition);
-     }
-+    // Paper start
-+    public CraftSmithingRecipe(NamespacedKey key, ItemStack result, RecipeChoice base, RecipeChoice addition, boolean copyNbt) {
-+        super(key, result, base, addition, copyNbt);
-+    }
-+    // Paper end
- 
-     public static CraftSmithingRecipe fromBukkitRecipe(SmithingRecipe recipe) {
-         if (recipe instanceof CraftSmithingRecipe) {
-             return (CraftSmithingRecipe) recipe;
-         }
--        CraftSmithingRecipe ret = new CraftSmithingRecipe(recipe.getKey(), recipe.getResult(), recipe.getBase(), recipe.getAddition());
-+        CraftSmithingRecipe ret = new CraftSmithingRecipe(recipe.getKey(), recipe.getResult(), recipe.getBase(), recipe.getAddition(), recipe.willCopyNbt()); // Paper
-         return ret;
-     }
- 
-@@ -0,0 +0,0 @@ public class CraftSmithingRecipe extends SmithingRecipe implements CraftRecipe {
-     public void addToCraftingManager() {
-         ItemStack result = this.getResult();
- 
--        MinecraftServer.getServer().getRecipeManager().addRecipe(new net.minecraft.world.item.crafting.LegacyUpgradeRecipe(CraftNamespacedKey.toMinecraft(this.getKey()), toNMS(this.getBase(), true), toNMS(this.getAddition(), true), CraftItemStack.asNMSCopy(result)));
-+        MinecraftServer.getServer().getRecipeManager().addRecipe(new net.minecraft.world.item.crafting.LegacyUpgradeRecipe(CraftNamespacedKey.toMinecraft(this.getKey()), toNMS(this.getBase(), true), toNMS(this.getAddition(), true), CraftItemStack.asNMSCopy(result), this.willCopyNbt())); // Paper
-     }
- }