net.minecraft.world.item

paper-server/patches/sources/net/minecraft/world/item/BlockItem.java.patch

@@ -0,0 +1,13 @@
+--- a/net/minecraft/world/item/BlockItem.java
++++ b/net/minecraft/world/item/BlockItem.java
+@@ -9,9 +_,9 @@
+ import net.minecraft.core.registries.Registries;
+ import net.minecraft.nbt.CompoundTag;
+ import net.minecraft.network.chat.Component;
++import net.minecraft.server.level.ServerLevel;
+ import net.minecraft.server.level.ServerPlayer;
+ import net.minecraft.sounds.SoundEvent;
+-import net.minecraft.sounds.SoundSource;
+ import net.minecraft.world.InteractionResult;
+ import net.minecraft.world.entity.item.ItemEntity;
+ import net.minecraft.world.entity.player.Player;

paper-server/patches/sources/net/minecraft/world/item/DebugStickItem.java.patch

@@ -0,0 +1,7 @@
+--- a/net/minecraft/world/item/DebugStickItem.java
++++ b/net/minecraft/world/item/DebugStickItem.java
+@@ -1,3 +_,4 @@
++// mc-dev import
+ package net.minecraft.world.item;
+ 
+ import java.util.Collection;

paper-server/patches/sources/net/minecraft/world/item/ExperienceBottleItem.java.patch

@@ -0,0 +1,54 @@
+--- a/net/minecraft/world/item/ExperienceBottleItem.java
++++ b/net/minecraft/world/item/ExperienceBottleItem.java
+@@ -21,22 +_,38 @@
+     @Override
+     public InteractionResult use(Level level, Player player, InteractionHand hand) {
+         ItemStack itemInHand = player.getItemInHand(hand);
+-        level.playSound(
+-            null,
+-            player.getX(),
+-            player.getY(),
+-            player.getZ(),
+-            SoundEvents.EXPERIENCE_BOTTLE_THROW,
+-            SoundSource.NEUTRAL,
+-            0.5F,
+-            0.4F / (level.getRandom().nextFloat() * 0.4F + 0.8F)
+-        );
++        // Paper - PlayerLaunchProjectileEvent - moved down
+         if (level instanceof ServerLevel serverLevel) {
+-            Projectile.spawnProjectileFromRotation(ThrownExperienceBottle::new, serverLevel, itemInHand, player, -20.0F, 0.7F, 1.0F);
++            // Paper start - PlayerLaunchProjectileEvent
++            final Projectile.Delayed<ThrownExperienceBottle> thrownExperienceBottle = Projectile.spawnProjectileFromRotationDelayed(ThrownExperienceBottle::new, serverLevel, itemInHand, player, -20.0F, 0.7F, 1.0F);
++            com.destroystokyo.paper.event.player.PlayerLaunchProjectileEvent event = new com.destroystokyo.paper.event.player.PlayerLaunchProjectileEvent((org.bukkit.entity.Player) player.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemInHand), (org.bukkit.entity.Projectile) thrownExperienceBottle.projectile().getBukkitEntity());
++            if (event.callEvent() && thrownExperienceBottle.attemptSpawn()) {
++                if (event.shouldConsume()) {
++                    itemInHand.consume(1, player);
++                } else if (player instanceof net.minecraft.server.level.ServerPlayer) {
++                    ((net.minecraft.server.level.ServerPlayer) player).getBukkitEntity().updateInventory();
++                }
++
++                level.playSound(
++                    null,
++                    player.getX(),
++                    player.getY(),
++                    player.getZ(),
++                    SoundEvents.EXPERIENCE_BOTTLE_THROW,
++                    SoundSource.NEUTRAL,
++                    0.5F,
++                    0.4F / (level.getRandom().nextFloat() * 0.4F + 0.8F)
++                );
++            } else {
++                if (player instanceof net.minecraft.server.level.ServerPlayer) {
++                    ((net.minecraft.server.level.ServerPlayer) player).getBukkitEntity().updateInventory();
++                }
++                return InteractionResult.FAIL;
++            }
++            // Paper end - PlayerLaunchProjectileEvent
+         }
+ 
+-        player.awardStat(Stats.ITEM_USED.get(this));
+-        itemInHand.consume(1, player);
++        // Paper - PlayerLaunchProjectileEvent - moved up
+         return InteractionResult.SUCCESS;
+     }
+ 

paper-server/patches/sources/net/minecraft/world/item/FireChargeItem.java.patch

@@ -0,0 +1,31 @@
+--- a/net/minecraft/world/item/FireChargeItem.java
++++ b/net/minecraft/world/item/FireChargeItem.java
+@@ -35,12 +_,28 @@
+         if (!CampfireBlock.canLight(blockState) && !CandleBlock.canLight(blockState) && !CandleCakeBlock.canLight(blockState)) {
+             clickedPos = clickedPos.relative(context.getClickedFace());
+             if (BaseFireBlock.canBePlacedAt(level, clickedPos, context.getHorizontalDirection())) {
++                // CraftBukkit start - fire BlockIgniteEvent
++                if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockIgniteEvent(level, clickedPos, org.bukkit.event.block.BlockIgniteEvent.IgniteCause.FIREBALL, context.getPlayer()).isCancelled()) {
++                    if (!context.getPlayer().getAbilities().instabuild) {
++                        context.getItemInHand().shrink(1);
++                    }
++                    return InteractionResult.PASS;
++                }
++                // CraftBukkit end
+                 this.playSound(level, clickedPos);
+                 level.setBlockAndUpdate(clickedPos, BaseFireBlock.getState(level, clickedPos));
+                 level.gameEvent(context.getPlayer(), GameEvent.BLOCK_PLACE, clickedPos);
+                 flag = true;
+             }
+         } else {
++            // CraftBukkit start - fire BlockIgniteEvent
++            if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockIgniteEvent(level, clickedPos, org.bukkit.event.block.BlockIgniteEvent.IgniteCause.FIREBALL, context.getPlayer()).isCancelled()) {
++                if (!context.getPlayer().getAbilities().instabuild) {
++                    context.getItemInHand().shrink(1);
++                }
++                return InteractionResult.PASS;
++            }
++            // CraftBukkit end
+             this.playSound(level, clickedPos);
+             level.setBlockAndUpdate(clickedPos, blockState.setValue(BlockStateProperties.LIT, Boolean.valueOf(true)));
+             level.gameEvent(context.getPlayer(), GameEvent.BLOCK_CHANGE, clickedPos);

paper-server/patches/sources/net/minecraft/world/item/FireworkRocketItem.java.patch

@@ -0,0 +1,51 @@
+--- a/net/minecraft/world/item/FireworkRocketItem.java
++++ b/net/minecraft/world/item/FireworkRocketItem.java
+@@ -33,7 +_,7 @@
+             ItemStack itemInHand = context.getItemInHand();
+             Vec3 clickLocation = context.getClickLocation();
+             Direction clickedFace = context.getClickedFace();
+-            Projectile.spawnProjectile(
++            final Projectile.Delayed<FireworkRocketEntity> fireworkRocketEntity = Projectile.spawnProjectileDelayed( // Paper - PlayerLaunchProjectileEvent
+                 new FireworkRocketEntity(
+                     level,
+                     context.getPlayer(),
+@@ -43,9 +_,14 @@
+                     itemInHand
+                 ),
+                 serverLevel,
+-                itemInHand
++                itemInHand, f -> f.spawningEntity = context.getPlayer() == null ? null : context.getPlayer().getUUID()  // Paper - firework api - assign spawning entity uuid
+             );
+-            itemInHand.shrink(1);
++            // Paper start - PlayerLaunchProjectileEvent
++            com.destroystokyo.paper.event.player.PlayerLaunchProjectileEvent event = new com.destroystokyo.paper.event.player.PlayerLaunchProjectileEvent((org.bukkit.entity.Player) context.getPlayer().getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemInHand), (org.bukkit.entity.Firework) fireworkRocketEntity.projectile().getBukkitEntity());
++            if (!event.callEvent() || !fireworkRocketEntity.attemptSpawn()) return InteractionResult.PASS;
++            if (event.shouldConsume() && !context.getPlayer().hasInfiniteMaterials()) itemInHand.shrink(1);
++            else if (context.getPlayer() instanceof net.minecraft.server.level.ServerPlayer) ((net.minecraft.server.level.ServerPlayer) context.getPlayer()).getBukkitEntity().updateInventory();
++            // Paper end - PlayerLaunchProjectileEvent
+         }
+ 
+         return InteractionResult.SUCCESS;
+@@ -56,9 +_,19 @@
+         if (player.isFallFlying()) {
+             ItemStack itemInHand = player.getItemInHand(hand);
+             if (level instanceof ServerLevel serverLevel) {
+-                Projectile.spawnProjectile(new FireworkRocketEntity(level, itemInHand, player), serverLevel, itemInHand);
+-                itemInHand.consume(1, player);
+-                player.awardStat(Stats.ITEM_USED.get(this));
++                // Paper start - PlayerElytraBoostEvent
++                final Projectile.Delayed<FireworkRocketEntity> delayed = Projectile.spawnProjectileDelayed(new FireworkRocketEntity(level, itemInHand, player), serverLevel, itemInHand, f -> f.spawningEntity = player.getUUID());  // Paper - firework api - assign spawning entity uuid
++                com.destroystokyo.paper.event.player.PlayerElytraBoostEvent event = new com.destroystokyo.paper.event.player.PlayerElytraBoostEvent((org.bukkit.entity.Player) player.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemInHand), (org.bukkit.entity.Firework) delayed.projectile().getBukkitEntity(), org.bukkit.craftbukkit.CraftEquipmentSlot.getHand(hand));
++                if (event.callEvent() && delayed.attemptSpawn()) {
++                    player.awardStat(Stats.ITEM_USED.get(this)); // Moved up from below
++                    if (event.shouldConsume() && !player.hasInfiniteMaterials()) {
++                        itemInHand.shrink(1); // Moved up from below
++                    } else ((net.minecraft.server.level.ServerPlayer) player).getBukkitEntity().updateInventory();
++                } else {
++                    ((net.minecraft.server.level.ServerPlayer) player).getBukkitEntity().updateInventory();
++                }
++                // Moved up consume/stat
++                // Paper end - PlayerElytraBoostEvent
+             }
+ 
+             return InteractionResult.SUCCESS;

paper-server/patches/sources/net/minecraft/world/item/FishingRodItem.java.patch

@@ -0,0 +1,54 @@
+--- a/net/minecraft/world/item/FishingRodItem.java
++++ b/net/minecraft/world/item/FishingRodItem.java
+@@ -24,7 +_,7 @@
+         ItemStack itemInHand = player.getItemInHand(hand);
+         if (player.fishing != null) {
+             if (!level.isClientSide) {
+-                int i = player.fishing.retrieve(itemInHand);
++                int i = player.fishing.retrieve(hand, itemInHand); // Paper - Add hand parameter to PlayerFishEvent
+                 itemInHand.hurtAndBreak(i, player, LivingEntity.getSlotForHand(hand));
+             }
+ 
+@@ -40,20 +_,31 @@
+             );
+             player.gameEvent(GameEvent.ITEM_INTERACT_FINISH);
+         } else {
+-            level.playSound(
+-                null,
+-                player.getX(),
+-                player.getY(),
+-                player.getZ(),
+-                SoundEvents.FISHING_BOBBER_THROW,
+-                SoundSource.NEUTRAL,
+-                0.5F,
+-                0.4F / (level.getRandom().nextFloat() * 0.4F + 0.8F)
+-            );
++            // CraftBukkit - moved down
+             if (level instanceof ServerLevel serverLevel) {
+                 int i1 = (int)(EnchantmentHelper.getFishingTimeReduction(serverLevel, itemInHand, player) * 20.0F);
+                 int fishingLuckBonus = EnchantmentHelper.getFishingLuckBonus(serverLevel, itemInHand, player);
+-                Projectile.spawnProjectile(new FishingHook(player, level, fishingLuckBonus, i1), serverLevel, itemInHand);
++                // CraftBukkit start
++                FishingHook entityfishinghook = new FishingHook(player, level, fishingLuckBonus, i1);
++                org.bukkit.event.player.PlayerFishEvent playerFishEvent = new org.bukkit.event.player.PlayerFishEvent((org.bukkit.entity.Player) player.getBukkitEntity(), null, (org.bukkit.entity.FishHook) entityfishinghook.getBukkitEntity(), org.bukkit.craftbukkit.CraftEquipmentSlot.getHand(hand), org.bukkit.event.player.PlayerFishEvent.State.FISHING);
++                level.getCraftServer().getPluginManager().callEvent(playerFishEvent);
++
++                if (playerFishEvent.isCancelled()) {
++                    player.fishing = null;
++                    return InteractionResult.PASS;
++                }
++                level.playSound(
++                    null,
++                    player.getX(),
++                    player.getY(),
++                    player.getZ(),
++                    SoundEvents.FISHING_BOBBER_THROW,
++                    SoundSource.NEUTRAL,
++                    0.5F,
++                    0.4F / (level.getRandom().nextFloat() * 0.4F + 0.8F)
++                );
++                Projectile.spawnProjectile(entityfishinghook, serverLevel, itemInHand);
++                // CraftBukkit end
+             }
+ 
+             player.awardStat(Stats.ITEM_USED.get(this));

paper-server/patches/sources/net/minecraft/world/item/FlintAndSteelItem.java.patch

@@ -0,0 +1,28 @@
+--- a/net/minecraft/world/item/FlintAndSteelItem.java
++++ b/net/minecraft/world/item/FlintAndSteelItem.java
+@@ -32,6 +_,12 @@
+         if (!CampfireBlock.canLight(blockState) && !CandleBlock.canLight(blockState) && !CandleCakeBlock.canLight(blockState)) {
+             BlockPos blockPos = clickedPos.relative(context.getClickedFace());
+             if (BaseFireBlock.canBePlacedAt(level, blockPos, context.getHorizontalDirection())) {
++                // CraftBukkit start - Store the clicked block
++                if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockIgniteEvent(level, blockPos, org.bukkit.event.block.BlockIgniteEvent.IgniteCause.FLINT_AND_STEEL, player).isCancelled()) {
++                    context.getItemInHand().hurtAndBreak(1, player, LivingEntity.getSlotForHand(context.getHand()));
++                    return InteractionResult.PASS;
++                }
++                // CraftBukkit end
+                 level.playSound(player, blockPos, SoundEvents.FLINTANDSTEEL_USE, SoundSource.BLOCKS, 1.0F, level.getRandom().nextFloat() * 0.4F + 0.8F);
+                 BlockState state = BaseFireBlock.getState(level, blockPos);
+                 level.setBlock(blockPos, state, 11);
+@@ -47,6 +_,12 @@
+                 return InteractionResult.FAIL;
+             }
+         } else {
++            // CraftBukkit start - Store the clicked block
++            if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockIgniteEvent(level, clickedPos, org.bukkit.event.block.BlockIgniteEvent.IgniteCause.FLINT_AND_STEEL, player).isCancelled()) {
++                context.getItemInHand().hurtAndBreak(1, player, LivingEntity.getSlotForHand(context.getHand()));
++                return InteractionResult.PASS;
++            }
++            // CraftBukkit end
+             level.playSound(player, clickedPos, SoundEvents.FLINTANDSTEEL_USE, SoundSource.BLOCKS, 1.0F, level.getRandom().nextFloat() * 0.4F + 0.8F);
+             level.setBlock(clickedPos, blockState.setValue(BlockStateProperties.LIT, Boolean.valueOf(true)), 11);
+             level.gameEvent(player, GameEvent.BLOCK_CHANGE, clickedPos);

paper-server/patches/sources/net/minecraft/world/item/HangingEntityItem.java.patch

@@ -0,0 +1,22 @@
+--- a/net/minecraft/world/item/HangingEntityItem.java
++++ b/net/minecraft/world/item/HangingEntityItem.java
+@@ -66,6 +_,19 @@
+ 
+             if (hangingEntity.survives()) {
+                 if (!level.isClientSide) {
++                    // CraftBukkit start - fire HangingPlaceEvent
++                    org.bukkit.entity.Player who = (context.getPlayer() == null) ? null : (org.bukkit.entity.Player) context.getPlayer().getBukkitEntity();
++                    org.bukkit.block.Block blockClicked = level.getWorld().getBlockAt(blockPos.getX(), blockPos.getY(), blockPos.getZ());
++                    org.bukkit.block.BlockFace blockFace = org.bukkit.craftbukkit.block.CraftBlock.notchToBlockFace(clickedFace);
++                    org.bukkit.inventory.EquipmentSlot hand = org.bukkit.craftbukkit.CraftEquipmentSlot.getHand(context.getHand());
++
++                    org.bukkit.event.hanging.HangingPlaceEvent event = new org.bukkit.event.hanging.HangingPlaceEvent((org.bukkit.entity.Hanging) hangingEntity.getBukkitEntity(), who, blockClicked, blockFace, hand, org.bukkit.craftbukkit.inventory.CraftItemStack.asBukkitCopy(itemInHand));
++                    level.getCraftServer().getPluginManager().callEvent(event);
++
++                    if (event.isCancelled()) {
++                        return InteractionResult.FAIL;
++                    }
++                    // CraftBukkit end
+                     hangingEntity.playPlacementSound();
+                     level.gameEvent(player, GameEvent.ENTITY_PLACE, hangingEntity.position());
+                     level.addFreshEntity(hangingEntity);

paper-server/patches/sources/net/minecraft/world/item/HoneycombItem.java.patch

@@ -0,0 +1,17 @@
+--- a/net/minecraft/world/item/HoneycombItem.java
++++ b/net/minecraft/world/item/HoneycombItem.java
+@@ -74,6 +_,14 @@
+         return getWaxed(blockState).<InteractionResult>map(blockState1 -> {
+             Player player = context.getPlayer();
+             ItemStack itemInHand = context.getItemInHand();
++            // Paper start - EntityChangeBlockEvent
++            if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(player, clickedPos, blockState)) {
++                if (!player.isCreative()) {
++                    player.containerMenu.sendAllDataToRemote();
++                }
++                return InteractionResult.PASS;
++            }
++            // Paper end
+             if (player instanceof ServerPlayer serverPlayer) {
+                 CriteriaTriggers.ITEM_USED_ON_BLOCK.trigger(serverPlayer, clickedPos, itemInHand);
+             }

paper-server/patches/sources/net/minecraft/world/item/ItemCooldowns.java.patch

@@ -0,0 +1,16 @@
+--- a/net/minecraft/world/item/ItemCooldowns.java
++++ b/net/minecraft/world/item/ItemCooldowns.java
+@@ -56,6 +_,13 @@
+     }
+ 
+     public void addCooldown(ResourceLocation group, int cooldown) {
++        // Paper start - Item cooldown events
++        this.addCooldown(group, cooldown, true);
++    }
++
++    public void addCooldown(ResourceLocation group, int cooldown, boolean callEvent) {
++        // Event called in server override
++        // Paper end - Item cooldown events
+         this.cooldowns.put(group, new ItemCooldowns.CooldownInstance(this.tickCount, this.tickCount + cooldown));
+         this.onCooldownStarted(group, cooldown);
+     }

paper-server/patches/sources/net/minecraft/world/item/ItemStack.java.patch

@@ -0,0 +1,404 @@
+--- a/net/minecraft/world/item/ItemStack.java
++++ b/net/minecraft/world/item/ItemStack.java
+@@ -22,6 +_,7 @@
+ import net.minecraft.ChatFormatting;
+ import net.minecraft.advancements.CriteriaTriggers;
+ import net.minecraft.core.BlockPos;
++import net.minecraft.core.Direction;
+ import net.minecraft.core.Holder;
+ import net.minecraft.core.HolderLookup;
+ import net.minecraft.core.HolderSet;
+@@ -45,10 +_,12 @@
+ import net.minecraft.network.chat.MutableComponent;
+ import net.minecraft.network.codec.ByteBufCodecs;
+ import net.minecraft.network.codec.StreamCodec;
++import net.minecraft.network.protocol.game.ClientboundBlockUpdatePacket;
+ import net.minecraft.resources.RegistryOps;
+ import net.minecraft.server.level.ServerLevel;
+ import net.minecraft.server.level.ServerPlayer;
+ import net.minecraft.sounds.SoundEvent;
++import net.minecraft.sounds.SoundSource;
+ import net.minecraft.stats.Stats;
+ import net.minecraft.tags.TagKey;
+ import net.minecraft.util.ExtraCodecs;
+@@ -136,18 +_,35 @@
+             } else {
+                 Holder<Item> holder = ITEM_STREAM_CODEC.decode(buffer);
+                 DataComponentPatch dataComponentPatch = DataComponentPatch.STREAM_CODEC.decode(buffer);
+-                return new ItemStack(holder, varInt, dataComponentPatch);
++                // CraftBukkit start
++                ItemStack stack = new ItemStack(holder, varInt, dataComponentPatch);
++                if (false && !dataComponentPatch.isEmpty()) { // Paper - This is no longer needed with raw NBT being handled in metadata
++                    org.bukkit.craftbukkit.inventory.CraftItemStack.setItemMeta(stack, org.bukkit.craftbukkit.inventory.CraftItemStack.getItemMeta(stack));
++                }
++                return stack;
++                // CraftBukkit end
+             }
+         }
+ 
+         @Override
+         public void encode(RegistryFriendlyByteBuf buffer, ItemStack value) {
+-            if (value.isEmpty()) {
++            if (value.isEmpty() || value.getItem() == null) { // CraftBukkit - NPE fix itemstack.getItem()
+                 buffer.writeVarInt(0);
+             } else {
+                 buffer.writeVarInt(value.getCount());
+                 ITEM_STREAM_CODEC.encode(buffer, value.getItemHolder());
++                // Spigot start - filter
++                // value = value.copy();
++                // CraftItemStack.setItemMeta(value, CraftItemStack.getItemMeta(value)); // Paper - This is no longer with raw NBT being handled in metadata
++                // Paper start - adventure; conditionally render translatable components
++                boolean prev = net.minecraft.network.chat.ComponentSerialization.DONT_RENDER_TRANSLATABLES.get();
++                try {
++                    net.minecraft.network.chat.ComponentSerialization.DONT_RENDER_TRANSLATABLES.set(true);
+                 DataComponentPatch.STREAM_CODEC.encode(buffer, value.components.asPatch());
++                } finally {
++                    net.minecraft.network.chat.ComponentSerialization.DONT_RENDER_TRANSLATABLES.set(prev);
++                }
++                // Paper end - adventure; conditionally render translatable components
+             }
+         }
+     };
+@@ -365,10 +_,180 @@
+             return InteractionResult.PASS;
+         } else {
+             Item item = this.getItem();
+-            InteractionResult interactionResult = item.useOn(context);
++            // InteractionResult interactionResult = item.useOn(context);
++            // CraftBukkit start - handle all block place event logic here
++            DataComponentPatch oldData = this.components.asPatch();
++            int oldCount = this.getCount();
++            ServerLevel serverLevel = (ServerLevel) context.getLevel();
++
++            if (!(item instanceof BucketItem/* || item instanceof SolidBucketItem*/)) { // if not bucket // Paper - Fix cancelled powdered snow bucket placement
++                serverLevel.captureBlockStates = true;
++                // special case bonemeal
++                if (item == Items.BONE_MEAL) {
++                    serverLevel.captureTreeGeneration = true;
++                }
++            }
++            InteractionResult interactionResult;
++            try {
++                interactionResult = item.useOn(context);
++            } finally {
++                serverLevel.captureBlockStates = false;
++            }
++            DataComponentPatch newData = this.components.asPatch();
++            int newCount = this.getCount();
++            this.setCount(oldCount);
++            this.restorePatch(oldData);
++            if (interactionResult.consumesAction() && serverLevel.captureTreeGeneration && serverLevel.capturedBlockStates.size() > 0) {
++                serverLevel.captureTreeGeneration = false;
++                org.bukkit.Location location = org.bukkit.craftbukkit.util.CraftLocation.toBukkit(clickedPos, serverLevel.getWorld());
++                org.bukkit.TreeType treeType = net.minecraft.world.level.block.SaplingBlock.treeType;
++                net.minecraft.world.level.block.SaplingBlock.treeType = null;
++                List<org.bukkit.craftbukkit.block.CraftBlockState> blocks = new java.util.ArrayList<>(serverLevel.capturedBlockStates.values());
++                serverLevel.capturedBlockStates.clear();
++                org.bukkit.event.world.StructureGrowEvent structureEvent = null;
++                if (treeType != null) {
++                    boolean isBonemeal = this.getItem() == Items.BONE_MEAL;
++                    structureEvent = new org.bukkit.event.world.StructureGrowEvent(location, treeType, isBonemeal, (org.bukkit.entity.Player) player.getBukkitEntity(), (List<org.bukkit.block.BlockState>) (List<? extends org.bukkit.block.BlockState>) blocks);
++                    org.bukkit.Bukkit.getPluginManager().callEvent(structureEvent);
++                }
++
++                org.bukkit.event.block.BlockFertilizeEvent fertilizeEvent = new org.bukkit.event.block.BlockFertilizeEvent(org.bukkit.craftbukkit.block.CraftBlock.at(serverLevel, clickedPos), (org.bukkit.entity.Player) player.getBukkitEntity(), (List<org.bukkit.block.BlockState>) (List<? extends org.bukkit.block.BlockState>) blocks);
++                fertilizeEvent.setCancelled(structureEvent != null && structureEvent.isCancelled());
++                org.bukkit.Bukkit.getPluginManager().callEvent(fertilizeEvent);
++
++                if (!fertilizeEvent.isCancelled()) {
++                    // Change the stack to its new contents if it hasn't been tampered with.
++                    if (this.getCount() == oldCount && Objects.equals(this.components.asPatch(), oldData)) {
++                        this.restorePatch(newData);
++                        this.setCount(newCount);
++                    }
++                    for (org.bukkit.craftbukkit.block.CraftBlockState blockstate : blocks) {
++                        // SPIGOT-7572 - Move fix for SPIGOT-7248 to CapturedBlockState, to allow bees in bee nest
++                        org.bukkit.craftbukkit.block.CapturedBlockState.setBlockState(blockstate);
++                        serverLevel.checkCapturedTreeStateForObserverNotify(clickedPos, blockstate); // Paper - notify observers even if grow failed
++                    }
++                    player.awardStat(Stats.ITEM_USED.get(item)); // SPIGOT-7236 - award stat
++                }
++
++                SignItem.openSign = null; // SPIGOT-6758 - Reset on early return
++                return interactionResult;
++            }
++            serverLevel.captureTreeGeneration = false;
+             if (player != null && interactionResult instanceof InteractionResult.Success success && success.wasItemInteraction()) {
+-                player.awardStat(Stats.ITEM_USED.get(item));
++                // player.awardStat(Stats.ITEM_USED.get(item));
++                InteractionHand enumhand = context.getHand();
++                org.bukkit.event.block.BlockPlaceEvent placeEvent = null;
++                List<org.bukkit.block.BlockState> blocks = new java.util.ArrayList<>(serverLevel.capturedBlockStates.values());
++                serverLevel.capturedBlockStates.clear();
++                if (blocks.size() > 1) {
++                    placeEvent = org.bukkit.craftbukkit.event.CraftEventFactory.callBlockMultiPlaceEvent(serverLevel, player, enumhand, blocks, clickedPos.getX(), clickedPos.getY(), clickedPos.getZ());
++                } else if (blocks.size() == 1 && item != Items.POWDER_SNOW_BUCKET) { // Paper - Fix cancelled powdered snow bucket placement
++                    placeEvent = org.bukkit.craftbukkit.event.CraftEventFactory.callBlockPlaceEvent(serverLevel, player, enumhand, blocks.get(0), clickedPos.getX(), clickedPos.getY(), clickedPos.getZ());
++                }
++
++                if (placeEvent != null && (placeEvent.isCancelled() || !placeEvent.canBuild())) {
++                    interactionResult = InteractionResult.FAIL; // cancel placement
++                    // PAIL: Remove this when MC-99075 fixed
++                    placeEvent.getPlayer().updateInventory();
++                    serverLevel.capturedTileEntities.clear(); // Paper - Allow chests to be placed with NBT data; clear out block entities as chests and such will pop loot
++                    // revert back all captured blocks
++                    serverLevel.preventPoiUpdated = true; // CraftBukkit - SPIGOT-5710
++                serverLevel.isBlockPlaceCancelled = true; // Paper - prevent calling cleanup logic when undoing a block place upon a cancelled BlockPlaceEvent
++                    for (org.bukkit.block.BlockState blockstate : blocks) {
++                        blockstate.update(true, false);
++                    }
++                serverLevel.isBlockPlaceCancelled = false; // Paper - prevent calling cleanup logic when undoing a block place upon a cancelled BlockPlaceEvent
++                    serverLevel.preventPoiUpdated = false;
++
++                    // Brute force all possible updates
++                    // Paper start - Don't resync blocks
++                    // BlockPos placedPos = ((CraftBlock) placeEvent.getBlock()).getPosition();
++                    // for (Direction dir : Direction.values()) {
++                    //     ((ServerPlayer) entityhuman).connection.send(new ClientboundBlockUpdatePacket(world, placedPos.relative(dir)));
++                    // }
++                    // Paper end - Don't resync blocks
++                    SignItem.openSign = null; // SPIGOT-6758 - Reset on early return
++                } else {
++                    // Change the stack to its new contents if it hasn't been tampered with.
++                    if (this.getCount() == oldCount && Objects.equals(this.components.asPatch(), oldData)) {
++                        this.restorePatch(newData);
++                        this.setCount(newCount);
++                    }
++
++                    for (java.util.Map.Entry<BlockPos, net.minecraft.world.level.block.entity.BlockEntity> e : serverLevel.capturedTileEntities.entrySet()) {
++                        serverLevel.setBlockEntity(e.getValue());
++                    }
++
++                    for (org.bukkit.block.BlockState blockstate : blocks) {
++                        int updateFlag = ((org.bukkit.craftbukkit.block.CraftBlockState) blockstate).getFlag();
++                        net.minecraft.world.level.block.state.BlockState oldBlock = ((org.bukkit.craftbukkit.block.CraftBlockState) blockstate).getHandle();
++                        BlockPos newblockposition = ((org.bukkit.craftbukkit.block.CraftBlockState) blockstate).getPosition();
++                        net.minecraft.world.level.block.state.BlockState block = serverLevel.getBlockState(newblockposition);
++
++                        if (!(block.getBlock() instanceof net.minecraft.world.level.block.BaseEntityBlock)) { // Containers get placed automatically
++                            block.onPlace(serverLevel, newblockposition, oldBlock, true, context);
++                        }
++
++                        serverLevel.notifyAndUpdatePhysics(newblockposition, null, oldBlock, block, serverLevel.getBlockState(newblockposition), updateFlag, 512); // send null chunk as chunk.k() returns false by this point
++                    }
++
++                    if (this.item == Items.WITHER_SKELETON_SKULL) { // Special case skulls to allow wither spawns to be cancelled
++                        BlockPos bp = clickedPos;
++                        if (!serverLevel.getBlockState(clickedPos).canBeReplaced()) {
++                            if (!serverLevel.getBlockState(clickedPos).isSolid()) {
++                                bp = null;
++                            } else {
++                                bp = bp.relative(context.getClickedFace());
++                            }
++                        }
++                        if (bp != null) {
++                            net.minecraft.world.level.block.entity.BlockEntity te = serverLevel.getBlockEntity(bp);
++                            if (te instanceof net.minecraft.world.level.block.entity.SkullBlockEntity) {
++                                net.minecraft.world.level.block.WitherSkullBlock.checkSpawn(serverLevel, bp, (net.minecraft.world.level.block.entity.SkullBlockEntity) te);
++                            }
++                        }
++                    }
++
++                    // SPIGOT-4678
++                    if (this.item instanceof SignItem && SignItem.openSign != null) {
++                        try {
++                            if (serverLevel.getBlockEntity(SignItem.openSign) instanceof net.minecraft.world.level.block.entity.SignBlockEntity tileentitysign) {
++                                if (serverLevel.getBlockState(SignItem.openSign).getBlock() instanceof net.minecraft.world.level.block.SignBlock blocksign) {
++                                    blocksign.openTextEdit(player, tileentitysign, true, io.papermc.paper.event.player.PlayerOpenSignEvent.Cause.PLACE); // Craftbukkit // Paper - Add PlayerOpenSignEvent
++                                }
++                            }
++                        } finally {
++                            SignItem.openSign = null;
++                        }
++                    }
++
++                    // SPIGOT-7315: Moved from BlockBed#setPlacedBy
++                    if (placeEvent != null && this.item instanceof BedItem) {
++                        BlockPos position = ((org.bukkit.craftbukkit.block.CraftBlock) placeEvent.getBlock()).getPosition();
++                        net.minecraft.world.level.block.state.BlockState blockData = serverLevel.getBlockState(position);
++
++                        if (blockData.getBlock() instanceof net.minecraft.world.level.block.BedBlock) {
++                            serverLevel.blockUpdated(position, net.minecraft.world.level.block.Blocks.AIR);
++                            blockData.updateNeighbourShapes(serverLevel, position, 3);
++                        }
++                    }
++
++                    // SPIGOT-1288 - play sound stripped from ItemBlock
++                    if (this.item instanceof BlockItem) {
++                    // Paper start - Fix spigot sound playing for BlockItem ItemStacks
++                    BlockPos position = new net.minecraft.world.item.context.BlockPlaceContext(context).getClickedPos();
++                    net.minecraft.world.level.block.state.BlockState blockData = serverLevel.getBlockState(position);
++                    net.minecraft.world.level.block.SoundType soundeffecttype = blockData.getSoundType();
++                    // Paper end - Fix spigot sound playing for BlockItem ItemStacks
++                        serverLevel.playSound(player, clickedPos, soundeffecttype.getPlaceSound(), SoundSource.BLOCKS, (soundeffecttype.getVolume() + 1.0F) / 2.0F, soundeffecttype.getPitch() * 0.8F);
++                    }
++
++                    player.awardStat(Stats.ITEM_USED.get(item));
++                }
+             }
++            serverLevel.capturedTileEntities.clear();
++            serverLevel.capturedBlockStates.clear();
++            // CraftBukkit end
+ 
+             return interactionResult;
+         }
+@@ -470,30 +_,69 @@
+     }
+ 
+     public void hurtAndBreak(int damage, ServerLevel level, @Nullable ServerPlayer player, Consumer<Item> onBreak) {
+-        int i = this.processDurabilityChange(damage, level, player);
++        // Paper start - add force boolean overload
++        this.hurtAndBreak(damage, level, player, onBreak, false);
++    }
++    public void hurtAndBreak(int damage, ServerLevel level, @Nullable LivingEntity player, Consumer<Item> onBreak, boolean force) {  // Paper - Add EntityDamageItemEvent
++        // Paper end
++        final int originalDamage = damage; // Paper - Expand PlayerItemDamageEvent
++        int i = this.processDurabilityChange(damage, level, player, force); // Paper
++        // CraftBukkit start
++        if (player instanceof final ServerPlayer serverPlayer) { // Paper - Add EntityDamageItemEvent
++            org.bukkit.event.player.PlayerItemDamageEvent event = new org.bukkit.event.player.PlayerItemDamageEvent(serverPlayer.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(this), i, originalDamage); // Paper - Add EntityDamageItemEvent
++            event.getPlayer().getServer().getPluginManager().callEvent(event);
++
++            if (i != event.getDamage() || event.isCancelled()) {
++                event.getPlayer().updateInventory();
++            }
++            if (event.isCancelled()) {
++                return;
++            }
++
++            i = event.getDamage();
++            // Paper start - Add EntityDamageItemEvent
++        } else if (player != null) {
++            io.papermc.paper.event.entity.EntityDamageItemEvent event = new io.papermc.paper.event.entity.EntityDamageItemEvent(player.getBukkitLivingEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(this), i);
++            if (!event.callEvent()) {
++                return;
++            }
++            i = event.getDamage();
++            // Paper end - Add EntityDamageItemEvent
++        }
++        // CraftBukkit end
+         if (i != 0) {
+             this.applyDamage(this.getDamageValue() + i, player, onBreak);
+         }
+     }
+ 
+-    private int processDurabilityChange(int damage, ServerLevel level, @Nullable ServerPlayer player) {
++    private int processDurabilityChange(int damage, ServerLevel level, @Nullable LivingEntity player) { // Paper - Add EntityDamageItemEvent
++        // Paper start - itemstack damage api
++        return processDurabilityChange(damage, level, player, false);
++    }
++    private int processDurabilityChange(int damage, ServerLevel level, @Nullable LivingEntity player, boolean force) {
++        // Paper end - itemstack damage api
+         if (!this.isDamageableItem()) {
+             return 0;
+-        } else if (player != null && player.hasInfiniteMaterials()) {
++        } else if (player instanceof ServerPlayer && player.hasInfiniteMaterials() && !force) { // Paper - Add EntityDamageItemEvent
+             return 0;
+         } else {
+             return damage > 0 ? EnchantmentHelper.processDurabilityChange(level, this, damage) : damage;
+         }
+     }
+ 
+-    private void applyDamage(int damage, @Nullable ServerPlayer player, Consumer<Item> onBreak) {
+-        if (player != null) {
+-            CriteriaTriggers.ITEM_DURABILITY_CHANGED.trigger(player, this, damage);
++    private void applyDamage(int damage, @Nullable LivingEntity player, Consumer<Item> onBreak) { // Paper - Add EntityDamageItemEvent
++        if (player instanceof final ServerPlayer serverPlayer) { // Paper - Add EntityDamageItemEvent
++            CriteriaTriggers.ITEM_DURABILITY_CHANGED.trigger(serverPlayer, this, damage); // Paper - Add EntityDamageItemEvent
+         }
+ 
+         this.setDamageValue(damage);
+         if (this.isBroken()) {
+             Item item = this.getItem();
++            // CraftBukkit start - Check for item breaking
++            if (this.count == 1 && player instanceof final ServerPlayer serverPlayer) { // Paper - Add EntityDamageItemEvent
++                org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerItemBreakEvent(serverPlayer, this); // Paper - Add EntityDamageItemEvent
++            }
++            // CraftBukkit end
+             this.shrink(1);
+             onBreak.accept(item);
+         }
+@@ -512,9 +_,14 @@
+     }
+ 
+     public void hurtAndBreak(int amount, LivingEntity entity, EquipmentSlot slot) {
++        // Paper start - add param to skip infinite mats check
++        this.hurtAndBreak(amount, entity, slot, false);
++    }
++    public void hurtAndBreak(int amount, LivingEntity entity, EquipmentSlot slot, boolean force) {
++        // Paper end - add param to skip infinite mats check
+         if (entity.level() instanceof ServerLevel serverLevel) {
+             this.hurtAndBreak(
+-                amount, serverLevel, entity instanceof ServerPlayer serverPlayer ? serverPlayer : null, item -> entity.onEquippedItemBroken(item, slot)
++                amount, serverLevel, entity, item -> {if (slot != null) entity.onEquippedItemBroken(item, slot); }, force // Paper - Add EntityDamageItemEvent & itemstack damage API - do not process entity related callbacks when damaging from API
+             );
+         }
+     }
+@@ -715,6 +_,12 @@
+         return this.getItem().useOnRelease(this);
+     }
+ 
++    // CraftBukkit start
++    public void restorePatch(DataComponentPatch datacomponentpatch) {
++        this.components.restorePatch(datacomponentpatch);
++    }
++    // CraftBukkit end
++
+     @Nullable
+     public <T> T set(DataComponentType<? super T> component, @Nullable T value) {
+         return this.components.set(component, value);
+@@ -748,6 +_,25 @@
+         }
+     }
+ 
++    // Paper start - (this is just a good no conflict location)
++    public org.bukkit.inventory.ItemStack asBukkitMirror() {
++        return org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(this);
++    }
++    public org.bukkit.inventory.ItemStack asBukkitCopy() {
++        return org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(this.copy());
++    }
++    public static ItemStack fromBukkitCopy(org.bukkit.inventory.ItemStack itemstack) {
++        return org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(itemstack);
++    }
++    private org.bukkit.craftbukkit.inventory.CraftItemStack bukkitStack;
++    public org.bukkit.inventory.ItemStack getBukkitStack() {
++        if (bukkitStack == null || bukkitStack.handle != this) {
++            bukkitStack = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(this);
++        }
++        return bukkitStack;
++    }
++    // Paper end
++
+     public void applyComponents(DataComponentPatch components) {
+         this.components.applyPatch(components);
+         this.getItem().verifyComponentsAfterLoad(this);
+@@ -1016,6 +_,19 @@
+         EnchantmentHelper.forEachModifier(this, equipmentSLot, action);
+     }
+ 
++    // CraftBukkit start
++    @Deprecated
++    public void setItem(Item item) {
++        this.bukkitStack = null; // Paper
++        this.item = item;
++        // Paper start - change base component prototype
++        final DataComponentPatch patch = this.getComponentsPatch();
++        this.components = new PatchedDataComponentMap(this.item.components());
++        this.applyComponents(patch);
++        // Paper end - change base component prototype
++    }
++    // CraftBukkit end
++
+     public Component getDisplayName() {
+         MutableComponent mutableComponent = Component.empty().append(this.getHoverName());
+         if (this.has(DataComponents.CUSTOM_NAME)) {
+@@ -1072,7 +_,7 @@
+     }
+ 
+     public void consume(int amount, @Nullable LivingEntity entity) {
+-        if (entity == null || !entity.hasInfiniteMaterials()) {
++        if ((entity == null || !entity.hasInfiniteMaterials()) && this != ItemStack.EMPTY) { // CraftBukkit
+             this.shrink(amount);
+         }
+     }

paper-server/patches/sources/net/minecraft/world/item/ItemUtils.java.patch

@@ -0,0 +1,19 @@
+--- a/net/minecraft/world/item/ItemUtils.java
++++ b/net/minecraft/world/item/ItemUtils.java
+@@ -41,7 +_,15 @@
+     public static void onContainerDestroyed(ItemEntity container, Iterable<ItemStack> contents) {
+         Level level = container.level();
+         if (!level.isClientSide) {
+-            contents.forEach(itemStack -> level.addFreshEntity(new ItemEntity(level, container.getX(), container.getY(), container.getZ(), itemStack)));
++            // Paper start - call EntityDropItemEvent
++            contents.forEach(stack -> {
++                ItemEntity droppedItem = new ItemEntity(level, container.getX(), container.getY(), container.getZ(), stack);
++                org.bukkit.event.entity.EntityDropItemEvent event = new org.bukkit.event.entity.EntityDropItemEvent(container.getBukkitEntity(), (org.bukkit.entity.Item) droppedItem.getBukkitEntity());
++                if (event.callEvent()) {
++                    level.addFreshEntity(droppedItem);
++                }
++            });
++            // Paper end - call EntityDropItemEvent
+         }
+     }
+ }

paper-server/patches/sources/net/minecraft/world/item/LeadItem.java.patch

@@ -0,0 +1,70 @@
+--- a/net/minecraft/world/item/LeadItem.java
++++ b/net/minecraft/world/item/LeadItem.java
+@@ -28,23 +_,43 @@
+         if (blockState.is(BlockTags.FENCES)) {
+             Player player = context.getPlayer();
+             if (!level.isClientSide && player != null) {
+-                return bindPlayerMobs(player, level, clickedPos);
++                return bindPlayerMobs(player, level, clickedPos, context.getHand()); // CraftBukkit - Pass hand
+             }
+         }
+ 
+         return InteractionResult.PASS;
+     }
+ 
+-    public static InteractionResult bindPlayerMobs(Player player, Level level, BlockPos pos) {
++    public static InteractionResult bindPlayerMobs(Player player, Level level, BlockPos pos, net.minecraft.world.InteractionHand interactionHand) { // CraftBukkit - Add InteractionHand
+         LeashFenceKnotEntity leashFenceKnotEntity = null;
+         List<Leashable> list = leashableInArea(level, pos, leashable1 -> leashable1.getLeashHolder() == player);
+ 
+-        for (Leashable leashable : list) {
++        for (java.util.Iterator<Leashable> iterator = list.iterator(); iterator.hasNext();) { // Paper - use iterator to remove
++            Leashable leashable = iterator.next(); // Paper - use iterator to remove
+             if (leashFenceKnotEntity == null) {
+                 leashFenceKnotEntity = LeashFenceKnotEntity.getOrCreateKnot(level, pos);
++                // CraftBukkit start - fire HangingPlaceEvent
++                org.bukkit.inventory.EquipmentSlot hand = org.bukkit.craftbukkit.CraftEquipmentSlot.getHand(interactionHand);
++                org.bukkit.event.hanging.HangingPlaceEvent event = new org.bukkit.event.hanging.HangingPlaceEvent((org.bukkit.entity.Hanging) leashFenceKnotEntity.getBukkitEntity(), player != null ? (org.bukkit.entity.Player) player.getBukkitEntity() : null, org.bukkit.craftbukkit.block.CraftBlock.at(level, pos), org.bukkit.block.BlockFace.SELF, hand);
++                level.getCraftServer().getPluginManager().callEvent(event);
++
++                if (event.isCancelled()) {
++                    leashFenceKnotEntity.discard(null); // CraftBukkit - add Bukkit remove cause
++                    return InteractionResult.PASS;
++                }
++                // CraftBukkit end
+                 leashFenceKnotEntity.playPlacementSound();
+             }
+ 
++            // CraftBukkit start
++            if (leashable instanceof Entity leashed) {
++                if (org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerLeashEntityEvent(leashed, leashFenceKnotEntity, player, interactionHand).isCancelled()) {
++                    iterator.remove();
++                    continue;
++                }
++            }
++            // CraftBukkit end
++
+             leashable.setLeashedTo(leashFenceKnotEntity, true);
+         }
+ 
+@@ -52,9 +_,20 @@
+             level.gameEvent(GameEvent.BLOCK_ATTACH, pos, GameEvent.Context.of(player));
+             return InteractionResult.SUCCESS_SERVER;
+         } else {
++            // CraftBukkit start - remove leash if we do not leash any entity because of the cancelled event
++            if (leashFenceKnotEntity != null) {
++                leashFenceKnotEntity.discard(null);
++            }
++            // CraftBukkit end
+             return InteractionResult.PASS;
+         }
+     }
++
++    // CraftBukkit start
++    public static InteractionResult bindPlayerMobs(Player player, Level world, BlockPos pos) {
++        return LeadItem.bindPlayerMobs(player, world, pos, net.minecraft.world.InteractionHand.MAIN_HAND);
++    }
++    // CraftBukkit end
+ 
+     public static List<Leashable> leashableInArea(Level level, BlockPos pos, Predicate<Leashable> predicate) {
+         double d = 7.0;

paper-server/patches/sources/net/minecraft/world/item/LingeringPotionItem.java.patch

@@ -0,0 +1,21 @@
+--- a/net/minecraft/world/item/LingeringPotionItem.java
++++ b/net/minecraft/world/item/LingeringPotionItem.java
+@@ -24,6 +_,10 @@
+ 
+     @Override
+     public InteractionResult use(Level level, Player player, InteractionHand hand) {
++        // Paper start - PlayerLaunchProjectileEvent
++        final InteractionResult wrapper = super.use(level, player, hand);
++        if (wrapper instanceof InteractionResult.Fail) return wrapper;
++        // Paper end - PlayerLaunchProjectileEvent
+         level.playSound(
+             null,
+             player.getX(),
+@@ -34,6 +_,6 @@
+             0.5F,
+             0.4F / (level.getRandom().nextFloat() * 0.4F + 0.8F)
+         );
+-        return super.use(level, player, hand);
++        return wrapper; // Paper - PlayerLaunchProjectileEvent
+     }
+ }

paper-server/patches/sources/net/minecraft/world/item/MapItem.java.patch

@@ -0,0 +1,22 @@
+--- a/net/minecraft/world/item/MapItem.java
++++ b/net/minecraft/world/item/MapItem.java
+@@ -99,8 +_,8 @@
+                             int i9 = (i1 / i + i6 - 64) * i;
+                             int i10 = (i2 / i + i7 - 64) * i;
+                             Multiset<MapColor> multiset = LinkedHashMultiset.create();
+-                            LevelChunk chunk = level.getChunk(SectionPos.blockToSectionCoord(i9), SectionPos.blockToSectionCoord(i10));
+-                            if (!chunk.isEmpty()) {
++                            LevelChunk chunk = level.getChunkIfLoaded(SectionPos.blockToSectionCoord(i9), SectionPos.blockToSectionCoord(i10)); // Paper - Maps shouldn't load chunks
++                            if (chunk != null && !chunk.isEmpty()) { // Paper - Maps shouldn't load chunks
+                                 int i11 = 0;
+                                 double d1 = 0.0;
+                                 if (level.dimensionType().hasCeiling()) {
+@@ -207,7 +_,7 @@
+ 
+                 for (int i5 = 0; i5 < 128; i5++) {
+                     for (int i6 = 0; i6 < 128; i6++) {
+-                        Holder<Biome> biome = serverLevel.getBiome(mutableBlockPos.set((i3 + i6) * i, 0, (i4 + i5) * i));
++                        Holder<Biome> biome = serverLevel.getUncachedNoiseBiome((i3 + i6) * i, 0, (i4 + i5) * i); // Paper - Perf: Use seed based lookup for treasure maps
+                         flags[i5 * 128 + i6] = biome.is(BiomeTags.WATER_ON_MAP_OUTLINES);
+                     }
+                 }

paper-server/patches/sources/net/minecraft/world/item/MinecartItem.java.patch

@@ -0,0 +1,17 @@
+--- a/net/minecraft/world/item/MinecartItem.java
++++ b/net/minecraft/world/item/MinecartItem.java
+@@ -57,7 +_,13 @@
+                 }
+ 
+                 if (level instanceof ServerLevel serverLevel) {
+-                    serverLevel.addFreshEntity(abstractMinecart);
++                    // CraftBukkit start
++                    if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityPlaceEvent(context, abstractMinecart).isCancelled()) {
++                    if (context.getPlayer() != null) context.getPlayer().containerMenu.sendAllDataToRemote(); // Paper - Fix inventory desync
++                        return InteractionResult.FAIL;
++                    }
++                    // CraftBukkit end
++                    if (!serverLevel.addFreshEntity(abstractMinecart)) return InteractionResult.PASS; // CraftBukkit
+                     serverLevel.gameEvent(
+                         GameEvent.ENTITY_PLACE, clickedPos, GameEvent.Context.of(context.getPlayer(), serverLevel.getBlockState(clickedPos.below()))
+                     );

paper-server/patches/sources/net/minecraft/world/item/NameTagItem.java.patch

@@ -0,0 +1,18 @@
+--- a/net/minecraft/world/item/NameTagItem.java
++++ b/net/minecraft/world/item/NameTagItem.java
+@@ -18,8 +_,13 @@
+         Component component = stack.get(DataComponents.CUSTOM_NAME);
+         if (component != null && target.getType().canSerialize() && target.canBeNameTagged()) {
+             if (!player.level().isClientSide && target.isAlive()) {
+-                target.setCustomName(component);
+-                if (target instanceof Mob mob) {
++                // Paper start - Add PlayerNameEntityEvent
++                io.papermc.paper.event.player.PlayerNameEntityEvent event = new io.papermc.paper.event.player.PlayerNameEntityEvent(((net.minecraft.server.level.ServerPlayer) player).getBukkitEntity(), target.getBukkitLivingEntity(), io.papermc.paper.adventure.PaperAdventure.asAdventure(stack.getHoverName()), true);
++                if (!event.callEvent()) return InteractionResult.PASS;
++                LivingEntity newEntity = ((org.bukkit.craftbukkit.entity.CraftLivingEntity) event.getEntity()).getHandle();
++                newEntity.setCustomName(event.getName() != null ? io.papermc.paper.adventure.PaperAdventure.asVanilla(event.getName()) : null);
++                if (event.isPersistent() && newEntity instanceof Mob mob) {
++                // Paper end - Add PlayerNameEntityEvent
+                     mob.setPersistenceRequired();
+                 }
+ 

paper-server/patches/sources/net/minecraft/world/item/PotionItem.java.patch

@@ -0,0 +1,15 @@
+--- a/net/minecraft/world/item/PotionItem.java
++++ b/net/minecraft/world/item/PotionItem.java
+@@ -42,6 +_,12 @@
+         PotionContents potionContents = itemInHand.getOrDefault(DataComponents.POTION_CONTENTS, PotionContents.EMPTY);
+         BlockState blockState = level.getBlockState(clickedPos);
+         if (context.getClickedFace() != Direction.DOWN && blockState.is(BlockTags.CONVERTABLE_TO_MUD) && potionContents.is(Potions.WATER)) {
++            // Paper start
++            if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(player, clickedPos, Blocks.MUD.defaultBlockState())) {
++                player.containerMenu.sendAllDataToRemote();
++                return InteractionResult.PASS;
++            }
++            // Paper end
+             level.playSound(null, clickedPos, SoundEvents.GENERIC_SPLASH, SoundSource.BLOCKS, 1.0F, 1.0F);
+             player.setItemInHand(context.getHand(), ItemUtils.createFilledResult(itemInHand, player, new ItemStack(Items.GLASS_BOTTLE)));
+             player.awardStat(Stats.ITEM_USED.get(itemInHand.getItem()));

paper-server/patches/sources/net/minecraft/world/item/ProjectileWeaponItem.java.patch

@@ -0,0 +1,55 @@
+--- a/net/minecraft/world/item/ProjectileWeaponItem.java
++++ b/net/minecraft/world/item/ProjectileWeaponItem.java
+@@ -62,12 +_,25 @@
+                 float f4 = f2 + f3 * ((i + 1) / 2) * f1;
+                 f3 = -f3;
+                 int i1 = i;
+-                Projectile.spawnProjectile(
+-                    this.createProjectile(level, shooter, weapon, itemStack, isCrit),
+-                    level,
+-                    itemStack,
+-                    projectile -> this.shootProjectile(shooter, projectile, i1, velocity, inaccuracy, f4, target)
+-                );
++                // CraftBukkit start
++                Projectile projectile = this.createProjectile(level, shooter, weapon, itemStack, isCrit);
++                this.shootProjectile(shooter, projectile, i1, velocity, inaccuracy, f4, target);
++
++                org.bukkit.event.entity.EntityShootBowEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityShootBowEvent(shooter, weapon, itemStack, projectile, hand, velocity, true);
++                if (event.isCancelled()) {
++                    event.getProjectile().remove();
++                    return;
++                }
++
++                if (event.getProjectile() == projectile.getBukkitEntity()) {
++                    if (Projectile.spawnProjectile(projectile, level, itemStack).isRemoved()) {
++                        if (shooter instanceof net.minecraft.server.level.ServerPlayer) {
++                            ((net.minecraft.server.level.ServerPlayer) shooter).getBukkitEntity().updateInventory();
++                        }
++                        return;
++                    }
++                }
++                // CraftBukkit end
+                 weapon.hurtAndBreak(this.getDurabilityUse(itemStack), shooter, LivingEntity.getSlotForHand(hand));
+                 if (weapon.isEmpty()) {
+                     break;
+@@ -95,6 +_,11 @@
+     }
+ 
+     protected static List<ItemStack> draw(ItemStack weapon, ItemStack ammo, LivingEntity shooter) {
++        // Paper start
++        return draw(weapon, ammo, shooter, true);
++    }
++    protected static List<ItemStack> draw(ItemStack weapon, ItemStack ammo, LivingEntity shooter, boolean consume) {
++        // Paper end
+         if (ammo.isEmpty()) {
+             return List.of();
+         } else {
+@@ -103,7 +_,7 @@
+             ItemStack itemStack = ammo.copy();
+ 
+             for (int i1 = 0; i1 < i; i1++) {
+-                ItemStack itemStack1 = useAmmo(weapon, i1 == 0 ? ammo : itemStack, shooter, i1 > 0);
++                ItemStack itemStack1 = useAmmo(weapon, i1 == 0 ? ammo : itemStack, shooter, i1 > 0 || !consume); // Paper
+                 if (!itemStack1.isEmpty()) {
+                     list.add(itemStack1);
+                 }

paper-server/patches/sources/net/minecraft/world/item/ServerItemCooldowns.java.patch

@@ -0,0 +1,42 @@
+--- a/net/minecraft/world/item/ServerItemCooldowns.java
++++ b/net/minecraft/world/item/ServerItemCooldowns.java
+@@ -11,6 +_,39 @@
+         this.player = player;
+     }
+ 
++    // Paper start - Add PlayerItemCooldownEvent
++    @Override
++    public void addCooldown(ItemStack item, int duration) {
++        final ResourceLocation cooldownGroup = this.getCooldownGroup(item);
++        final io.papermc.paper.event.player.PlayerItemCooldownEvent event = new io.papermc.paper.event.player.PlayerItemCooldownEvent(
++            this.player.getBukkitEntity(),
++            org.bukkit.craftbukkit.inventory.CraftItemType.minecraftToBukkit(item.getItem()),
++            org.bukkit.craftbukkit.util.CraftNamespacedKey.fromMinecraft(cooldownGroup),
++            duration
++        );
++        if (event.callEvent()) {
++            super.addCooldown(cooldownGroup, event.getCooldown(), false);
++        }
++    }
++
++    @Override
++    public void addCooldown(ResourceLocation groupId, int duration, boolean callEvent) {
++        if (callEvent) {
++            final io.papermc.paper.event.player.PlayerItemGroupCooldownEvent event = new io.papermc.paper.event.player.PlayerItemGroupCooldownEvent(
++                this.player.getBukkitEntity(),
++                org.bukkit.craftbukkit.util.CraftNamespacedKey.fromMinecraft(groupId),
++                duration
++            );
++            if (!event.callEvent()) {
++                return;
++            }
++
++            duration = event.getCooldown();
++        }
++        super.addCooldown(groupId, duration, false);
++    }
++    // Paper end - Add PlayerItemCooldownEvent
++
+     @Override
+     protected void onCooldownStarted(ResourceLocation group, int cooldown) {
+         super.onCooldownStarted(group, cooldown);

paper-server/patches/sources/net/minecraft/world/item/ShovelItem.java.patch

@@ -0,0 +1,33 @@
+--- a/net/minecraft/world/item/ShovelItem.java
++++ b/net/minecraft/world/item/ShovelItem.java
+@@ -46,20 +_,29 @@
+             Player player = context.getPlayer();
+             BlockState blockState1 = FLATTENABLES.get(blockState.getBlock());
+             BlockState blockState2 = null;
++            Runnable afterAction = null; // Paper
+             if (blockState1 != null && level.getBlockState(clickedPos.above()).isAir()) {
+-                level.playSound(player, clickedPos, SoundEvents.SHOVEL_FLATTEN, SoundSource.BLOCKS, 1.0F, 1.0F);
++                afterAction = () -> level.playSound(player, clickedPos, SoundEvents.SHOVEL_FLATTEN, SoundSource.BLOCKS, 1.0F, 1.0F); // Paper
+                 blockState2 = blockState1;
+             } else if (blockState.getBlock() instanceof CampfireBlock && blockState.getValue(CampfireBlock.LIT)) {
++                afterAction = () -> { // Paper
+                 if (!level.isClientSide()) {
+                     level.levelEvent(null, 1009, clickedPos, 0);
+                 }
+ 
+                 CampfireBlock.dowse(context.getPlayer(), level, clickedPos, blockState);
++                }; // Paper
+                 blockState2 = blockState.setValue(CampfireBlock.LIT, Boolean.valueOf(false));
+             }
+ 
+             if (blockState2 != null) {
+                 if (!level.isClientSide) {
++                    // Paper start
++                    if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(context.getPlayer(), clickedPos, blockState2)) {
++                        return InteractionResult.PASS;
++                    }
++                    afterAction.run();
++                    // Paper end
+                     level.setBlock(clickedPos, blockState2, 11);
+                     level.gameEvent(GameEvent.BLOCK_CHANGE, clickedPos, GameEvent.Context.of(player, blockState2));
+                     if (player != null) {

paper-server/patches/sources/net/minecraft/world/item/SignItem.java.patch

@@ -0,0 +1,22 @@
+--- a/net/minecraft/world/item/SignItem.java
++++ b/net/minecraft/world/item/SignItem.java
+@@ -11,6 +_,7 @@
+ import net.minecraft.world.level.block.state.BlockState;
+ 
+ public class SignItem extends StandingAndWallBlockItem {
++    public static BlockPos openSign; // CraftBukkit
+     public SignItem(Block standingBlock, Block wallBlock, Item.Properties properties) {
+         super(standingBlock, wallBlock, Direction.DOWN, properties);
+     }
+@@ -27,7 +_,10 @@
+             && player != null
+             && level.getBlockEntity(pos) instanceof SignBlockEntity signBlockEntity
+             && level.getBlockState(pos).getBlock() instanceof SignBlock signBlock) {
+-            signBlock.openTextEdit(player, signBlockEntity, true);
++            // CraftBukkit start - SPIGOT-4678
++            // signBlock.openTextEdit(player, signBlockEntity, true);
++            SignItem.openSign = pos;
++            // CraftBukkit end
+         }
+ 
+         return flag;

paper-server/patches/sources/net/minecraft/world/item/SnowballItem.java.patch

@@ -0,0 +1,54 @@
+--- a/net/minecraft/world/item/SnowballItem.java
++++ b/net/minecraft/world/item/SnowballItem.java
+@@ -23,22 +_,38 @@
+     @Override
+     public InteractionResult use(Level level, Player player, InteractionHand hand) {
+         ItemStack itemInHand = player.getItemInHand(hand);
+-        level.playSound(
+-            null,
+-            player.getX(),
+-            player.getY(),
+-            player.getZ(),
+-            SoundEvents.SNOWBALL_THROW,
+-            SoundSource.NEUTRAL,
+-            0.5F,
+-            0.4F / (level.getRandom().nextFloat() * 0.4F + 0.8F)
+-        );
++        // CraftBukkit start - moved down
+         if (level instanceof ServerLevel serverLevel) {
+-            Projectile.spawnProjectileFromRotation(Snowball::new, serverLevel, itemInHand, player, 0.0F, PROJECTILE_SHOOT_POWER, 1.0F);
++            // Paper start - PlayerLaunchProjectileEvent
++            final Projectile.Delayed<Snowball> snowball = Projectile.spawnProjectileFromRotationDelayed(Snowball::new, serverLevel, itemInHand, player, 0.0F, SnowballItem.PROJECTILE_SHOOT_POWER, 1.0F);
++            com.destroystokyo.paper.event.player.PlayerLaunchProjectileEvent event = new com.destroystokyo.paper.event.player.PlayerLaunchProjectileEvent((org.bukkit.entity.Player) player.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemInHand), (org.bukkit.entity.Projectile) snowball.projectile().getBukkitEntity());
++            if (event.callEvent() && snowball.attemptSpawn()) {
++                player.awardStat(Stats.ITEM_USED.get(this));
++                if (event.shouldConsume()) {
++                    itemInHand.consume(1, player);
++                } else if (player instanceof net.minecraft.server.level.ServerPlayer) {
++                    ((net.minecraft.server.level.ServerPlayer) player).getBukkitEntity().updateInventory();
++                }
++            // Paper end - PlayerLaunchProjectileEvent
++
++                level.playSound(
++                    null,
++                    player.getX(),
++                    player.getY(),
++                    player.getZ(),
++                    SoundEvents.SNOWBALL_THROW,
++                    SoundSource.NEUTRAL,
++                    0.5F,
++                    0.4F / (level.getRandom().nextFloat() * 0.4F + 0.8F)
++                );
++            } else { if (player instanceof net.minecraft.server.level.ServerPlayer) { // Paper - PlayerLaunchProjectileEvent - return fail
++                ((net.minecraft.server.level.ServerPlayer) player).getBukkitEntity().updateInventory();
++            } return InteractionResult.FAIL; } // Paper - PlayerLaunchProjectileEvent - return fail
++            // CraftBukkit end
+         }
+ 
+-        player.awardStat(Stats.ITEM_USED.get(this));
+-        itemInHand.consume(1, player);
++        // Paper - PlayerLaunchProjectileEvent - moved up
++        // itemInHand.consume(1, player); // CraftBukkit - moved up
+         return InteractionResult.SUCCESS;
+     }
+ 

paper-server/patches/sources/net/minecraft/world/item/SpawnEggItem.java.patch

@@ -0,0 +1,19 @@
+--- a/net/minecraft/world/item/SpawnEggItem.java
++++ b/net/minecraft/world/item/SpawnEggItem.java
+@@ -55,6 +_,7 @@
+             Direction clickedFace = context.getClickedFace();
+             BlockState blockState = level.getBlockState(clickedPos);
+             if (level.getBlockEntity(clickedPos) instanceof Spawner spawner) {
++                if (level.paperConfig().entities.spawning.disableMobSpawnerSpawnEggTransformation) return InteractionResult.FAIL; // Paper - Allow disabling mob spawner spawn egg transformation
+                 EntityType<?> type = this.getType(level.registryAccess(), itemInHand);
+                 spawner.setEntityId(type, level.getRandom());
+                 level.sendBlockUpdated(clickedPos, blockState, blockState, 3);
+@@ -169,7 +_,7 @@
+                     return Optional.empty();
+                 } else {
+                     breedOffspring.moveTo(pos.x(), pos.y(), pos.z(), 0.0F, 0.0F);
+-                    serverLevel.addFreshEntityWithPassengers(breedOffspring);
++                    serverLevel.addFreshEntityWithPassengers(breedOffspring, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.SPAWNER_EGG); // CraftBukkit
+                     breedOffspring.setCustomName(stack.get(DataComponents.CUSTOM_NAME));
+                     stack.consume(1, player);
+                     return Optional.of(breedOffspring);

paper-server/patches/sources/net/minecraft/world/item/SplashPotionItem.java.patch

@@ -0,0 +1,21 @@
+--- a/net/minecraft/world/item/SplashPotionItem.java
++++ b/net/minecraft/world/item/SplashPotionItem.java
+@@ -14,6 +_,10 @@
+ 
+     @Override
+     public InteractionResult use(Level level, Player player, InteractionHand hand) {
++        // Paper start - PlayerLaunchProjectileEvent
++        final InteractionResult wrapper = super.use(level, player, hand);
++        if (wrapper instanceof InteractionResult.Fail) return wrapper;
++        // Paper end - PlayerLaunchProjectileEvent
+         level.playSound(
+             null,
+             player.getX(),
+@@ -24,6 +_,6 @@
+             0.5F,
+             0.4F / (level.getRandom().nextFloat() * 0.4F + 0.8F)
+         );
+-        return super.use(level, player, hand);
++        return wrapper; // Paper - PlayerLaunchProjectileEvent
+     }
+ }

paper-server/patches/sources/net/minecraft/world/item/StandingAndWallBlockItem.java.patch

@@ -0,0 +1,24 @@
+--- a/net/minecraft/world/item/StandingAndWallBlockItem.java
++++ b/net/minecraft/world/item/StandingAndWallBlockItem.java
+@@ -42,7 +_,20 @@
+             }
+         }
+ 
+-        return blockState != null && level.isUnobstructed(blockState, clickedPos, CollisionContext.empty()) ? blockState : null;
++        // return blockState != null && level.isUnobstructed(blockState, clickedPos, CollisionContext.empty()) ? blockState : null;
++        // CraftBukkit start
++        if (blockState != null) {
++            boolean defaultReturn = level.isUnobstructed(blockState, clickedPos, CollisionContext.empty());
++            org.bukkit.entity.Player player = (context.getPlayer() instanceof net.minecraft.server.level.ServerPlayer) ? (org.bukkit.entity.Player) context.getPlayer().getBukkitEntity() : null;
++
++            org.bukkit.event.block.BlockCanBuildEvent event = new org.bukkit.event.block.BlockCanBuildEvent(org.bukkit.craftbukkit.block.CraftBlock.at(context.getLevel(), clickedPos), player, org.bukkit.craftbukkit.block.data.CraftBlockData.fromData(blockState), defaultReturn, org.bukkit.craftbukkit.CraftEquipmentSlot.getHand(context.getHand())); // Paper - Expose hand in BlockCanBuildEvent
++            context.getLevel().getCraftServer().getPluginManager().callEvent(event);
++
++            return (event.isBuildable()) ? blockState : null;
++        } else {
++            return null;
++        }
++        // CraftBukkit end
+     }
+ 
+     @Override

paper-server/patches/sources/net/minecraft/world/item/ThrowablePotionItem.java.patch

@@ -0,0 +1,35 @@
+--- a/net/minecraft/world/item/ThrowablePotionItem.java
++++ b/net/minecraft/world/item/ThrowablePotionItem.java
+@@ -22,11 +_,29 @@
+     public InteractionResult use(Level level, Player player, InteractionHand hand) {
+         ItemStack itemInHand = player.getItemInHand(hand);
+         if (level instanceof ServerLevel serverLevel) {
+-            Projectile.spawnProjectileFromRotation(ThrownPotion::new, serverLevel, itemInHand, player, -20.0F, PROJECTILE_SHOOT_POWER, 1.0F);
++            // Projectile.spawnProjectileFromRotation(ThrownPotion::new, serverLevel, itemInHand, player, -20.0F, PROJECTILE_SHOOT_POWER, 1.0F);
++            // Paper start - PlayerLaunchProjectileEvent
++            final Projectile.Delayed<ThrownPotion> thrownPotion = Projectile.spawnProjectileFromRotationDelayed(ThrownPotion::new, serverLevel, itemInHand, player, -20.0F, PROJECTILE_SHOOT_POWER, 1.0F);
++            // Paper start - PlayerLaunchProjectileEvent
++            com.destroystokyo.paper.event.player.PlayerLaunchProjectileEvent event = new com.destroystokyo.paper.event.player.PlayerLaunchProjectileEvent((org.bukkit.entity.Player) player.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemInHand), (org.bukkit.entity.Projectile) thrownPotion.projectile().getBukkitEntity());
++            if (event.callEvent() && thrownPotion.attemptSpawn()) {
++                if (event.shouldConsume()) {
++                    itemInHand.consume(1, player);
++                } else if (player instanceof net.minecraft.server.level.ServerPlayer) {
++                    ((net.minecraft.server.level.ServerPlayer) player).getBukkitEntity().updateInventory();
++                }
++
++                player.awardStat(Stats.ITEM_USED.get(this));
++            } else {
++                if (player instanceof net.minecraft.server.level.ServerPlayer) {
++                    ((net.minecraft.server.level.ServerPlayer) player).getBukkitEntity().updateInventory();
++                }
++                return InteractionResult.FAIL;
++            }
++            // Paper end - PlayerLaunchProjectileEvent
+         }
+ 
+-        player.awardStat(Stats.ITEM_USED.get(this));
+-        itemInHand.consume(1, player);
++        // Paper - PlayerLaunchProjectileEvent - move up
+         return InteractionResult.SUCCESS;
+     }
+ 

paper-server/patches/sources/net/minecraft/world/item/TridentItem.java.patch

@@ -0,0 +1,51 @@
+--- a/net/minecraft/world/item/TridentItem.java
++++ b/net/minecraft/world/item/TridentItem.java
+@@ -87,19 +_,37 @@
+                         .orElse(SoundEvents.TRIDENT_THROW);
+                     player.awardStat(Stats.ITEM_USED.get(this));
+                     if (level instanceof ServerLevel serverLevel) {
+-                        stack.hurtWithoutBreaking(1, player);
++                        // stack.hurtWithoutBreaking(1, player); // CraftBukkit - moved down
+                         if (tridentSpinAttackStrength == 0.0F) {
+-                            ThrownTrident thrownTrident = Projectile.spawnProjectileFromRotation(
++                            Projectile.Delayed<ThrownTrident> tridentDelayed = Projectile.spawnProjectileFromRotationDelayed( // Paper - PlayerLaunchProjectileEvent
+                                 ThrownTrident::new, serverLevel, stack, player, 0.0F, 2.5F, 1.0F
+                             );
++                            // Paper start - PlayerLaunchProjectileEvent
++                            com.destroystokyo.paper.event.player.PlayerLaunchProjectileEvent event = new com.destroystokyo.paper.event.player.PlayerLaunchProjectileEvent((org.bukkit.entity.Player) player.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(stack), (org.bukkit.entity.Projectile) tridentDelayed.projectile().getBukkitEntity());
++                            if (!event.callEvent() || !tridentDelayed.attemptSpawn()) {
++                                // CraftBukkit start
++                            // Paper end - PlayerLaunchProjectileEvent
++                                if (player instanceof net.minecraft.server.level.ServerPlayer serverPlayer) {
++                                    serverPlayer.getBukkitEntity().updateInventory();
++                                }
++                                return false;
++                            }
++                            ThrownTrident thrownTrident = tridentDelayed.projectile(); // Paper - PlayerLaunchProjectileEvent
++                            if (event.shouldConsume()) stack.hurtWithoutBreaking(1, player); // Paper - PlayerLaunchProjectileEvent
++                            thrownTrident.pickupItemStack = stack.copy(); // SPIGOT-4511 update since damage call moved
++                            // CraftBukkit end
+                             if (player.hasInfiniteMaterials()) {
+                                 thrownTrident.pickup = AbstractArrow.Pickup.CREATIVE_ONLY;
+-                            } else {
++                            } else if (event.shouldConsume()) { // Paper - PlayerLaunchProjectileEvent
+                                 player.getInventory().removeItem(stack);
+                             }
+ 
+                             level.playSound(null, thrownTrident, holder.value(), SoundSource.PLAYERS, 1.0F, 1.0F);
+                             return true;
++                            // CraftBukkit start - SPIGOT-5458 also need in this branch :(
++                        } else {
++                            stack.hurtWithoutBreaking(1, player);
++                            // CraftBukkit end
+                         }
+                     }
+ 
+@@ -113,6 +_,7 @@
+                         f *= tridentSpinAttackStrength / squareRoot;
+                         f1 *= tridentSpinAttackStrength / squareRoot;
+                         f2 *= tridentSpinAttackStrength / squareRoot;
++                        org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerRiptideEvent(player, stack, f, f1, f2); // CraftBukkit
+                         player.push(f, f1, f2);
+                         player.startAutoSpinAttack(20, 8.0F, stack);
+                         if (player.onGround()) {

paper-server/patches/sources/net/minecraft/world/item/WindChargeItem.java.patch

@@ -0,0 +1,44 @@
+--- a/net/minecraft/world/item/WindChargeItem.java
++++ b/net/minecraft/world/item/WindChargeItem.java
+@@ -27,7 +_,7 @@
+     public InteractionResult use(Level level, Player player, InteractionHand hand) {
+         ItemStack itemInHand = player.getItemInHand(hand);
+         if (level instanceof ServerLevel serverLevel) {
+-            Projectile.spawnProjectileFromRotation(
++            final Projectile.Delayed<WindCharge> windCharge = Projectile.spawnProjectileFromRotationDelayed( // Paper - PlayerLaunchProjectileEvent
+                 (level1, owner, spawnedFrom) -> new WindCharge(player, level, player.position().x(), player.getEyePosition().y(), player.position().z()),
+                 serverLevel,
+                 itemInHand,
+@@ -36,6 +_,22 @@
+                 PROJECTILE_SHOOT_POWER,
+                 1.0F
+             );
++            // Paper start - PlayerLaunchProjectileEvent
++            com.destroystokyo.paper.event.player.PlayerLaunchProjectileEvent event = new com.destroystokyo.paper.event.player.PlayerLaunchProjectileEvent((org.bukkit.entity.Player) player.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemInHand), (org.bukkit.entity.Projectile) windCharge.projectile().getBukkitEntity());
++            if (!event.callEvent() || !windCharge.attemptSpawn()) {
++                player.containerMenu.sendAllDataToRemote();
++                if (player instanceof net.minecraft.server.level.ServerPlayer serverPlayer) {
++                    serverPlayer.connection.send(new net.minecraft.network.protocol.game.ClientboundCooldownPacket(player.getCooldowns().getCooldownGroup(itemInHand), 0)); // prevent visual desync of cooldown on the slot
++                }
++                return InteractionResult.FAIL;
++            }
++
++            player.awardStat(Stats.ITEM_USED.get(this));
++            if (event.shouldConsume()) itemInHand.consume(1, player);
++            else if (!player.hasInfiniteMaterials()) {
++                player.containerMenu.sendAllDataToRemote();
++            }
++            // Paper end - PlayerLaunchProjectileEvent
+         }
+ 
+         level.playSound(
+@@ -48,8 +_,7 @@
+             0.5F,
+             0.4F / (level.getRandom().nextFloat() * 0.4F + 0.8F)
+         );
+-        player.awardStat(Stats.ITEM_USED.get(this));
+-        itemInHand.consume(1, player);
++        // Paper - PlayerLaunchProjectileEvent; moved up
+         return InteractionResult.SUCCESS;
+     }
+ 

paper-server/patches/sources/net/minecraft/world/item/WrittenBookItem.java.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/world/item/WrittenBookItem.java
++++ b/net/minecraft/world/item/WrittenBookItem.java
+@@ -41,7 +_,7 @@
+ 
+     public static boolean resolveBookComponents(ItemStack bookStack, CommandSourceStack resolvingSource, @Nullable Player resolvingPlayer) {
+         WrittenBookContent writtenBookContent = bookStack.get(DataComponents.WRITTEN_BOOK_CONTENT);
+-        if (writtenBookContent != null && !writtenBookContent.resolved()) {
++        if (io.papermc.paper.configuration.GlobalConfiguration.get().itemValidation.resolveSelectorsInBooks && writtenBookContent != null && !writtenBookContent.resolved()) { // Paper - Disable component selector resolving in books by default
+             WrittenBookContent writtenBookContent1 = writtenBookContent.resolve(resolvingSource, resolvingPlayer);
+             if (writtenBookContent1 != null) {
+                 bookStack.set(DataComponents.WRITTEN_BOOK_CONTENT, writtenBookContent1);