diff --git a/patches/unapplied/server/Add-API-to-get-the-collision-shape-of-a-block-before.patch b/patches/server/Add-API-to-get-the-collision-shape-of-a-block-before.patch similarity index 100% rename from patches/unapplied/server/Add-API-to-get-the-collision-shape-of-a-block-before.patch rename to patches/server/Add-API-to-get-the-collision-shape-of-a-block-before.patch diff --git a/patches/server/Add-BlockFailedDispenseEvent.patch b/patches/server/Add-BlockFailedDispenseEvent.patch index d425134361..43156fa42d 100644 --- a/patches/server/Add-BlockFailedDispenseEvent.patch +++ b/patches/server/Add-BlockFailedDispenseEvent.patch @@ -35,7 +35,7 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java +++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java -@@ -0,0 +0,0 @@ populateFields(victim, event); // Paper - make cancellable +@@ -0,0 +0,0 @@ public class CraftEventFactory { return org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(event.getPotion()); } // Paper end - WitchReadyPotionEvent diff --git a/patches/server/Add-BlockPreDispenseEvent.patch b/patches/server/Add-BlockPreDispenseEvent.patch index 81d0221fe1..d04ab08501 100644 --- a/patches/server/Add-BlockPreDispenseEvent.patch +++ b/patches/server/Add-BlockPreDispenseEvent.patch @@ -32,7 +32,7 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java +++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java -@@ -0,0 +0,0 @@ populateFields(victim, event); // Paper - make cancellable +@@ -0,0 +0,0 @@ public class CraftEventFactory { io.papermc.paper.event.block.BlockFailedDispenseEvent event = new io.papermc.paper.event.block.BlockFailedDispenseEvent(block); return event.callEvent(); } diff --git a/patches/server/Add-EntityFertilizeEggEvent.patch b/patches/server/Add-EntityFertilizeEggEvent.patch index 77f9effc79..665e1a469e 100644 --- a/patches/server/Add-EntityFertilizeEggEvent.patch +++ b/patches/server/Add-EntityFertilizeEggEvent.patch @@ -72,7 +72,7 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java +++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java -@@ -0,0 +0,0 @@ populateFields(victim, event); // Paper - make cancellable +@@ -0,0 +0,0 @@ public class CraftEventFactory { return event.callEvent(); } // Paper end diff --git a/patches/unapplied/server/Add-PlayerPickItemEvent.patch b/patches/server/Add-PlayerPickItemEvent.patch similarity index 84% rename from patches/unapplied/server/Add-PlayerPickItemEvent.patch rename to patches/server/Add-PlayerPickItemEvent.patch index 90bc5e8f68..a041c9e064 100644 --- a/patches/unapplied/server/Add-PlayerPickItemEvent.patch +++ b/patches/server/Add-PlayerPickItemEvent.patch @@ -13,20 +13,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 return; } - this.player.getInventory().pickSlot(packet.getSlot()); // Paper - Diff above if changed - // Paper end - validate pick item position + // Paper start - Add PlayerPickItemEvent ++ // this.player.getInventory().pickSlot(packet.getSlot()); // Paper - Diff above if changed - moved down + Player bukkitPlayer = this.player.getBukkitEntity(); + int targetSlot = this.player.getInventory().getSuitableHotbarSlot(); + int sourceSlot = packet.getSlot(); + + io.papermc.paper.event.player.PlayerPickItemEvent event = new io.papermc.paper.event.player.PlayerPickItemEvent(bukkitPlayer, targetSlot, sourceSlot); + if (!event.callEvent()) return; -+ -+ this.player.getInventory().pickSlot(event.getSourceSlot(), event.getTargetSlot()); + // Paper end - Add PlayerPickItemEvent - this.player.connection.send(new ClientboundContainerSetSlotPacket(-2, 0, this.player.getInventory().selected, this.player.getInventory().getItem(this.player.getInventory().selected))); - this.player.connection.send(new ClientboundContainerSetSlotPacket(-2, 0, packet.getSlot(), this.player.getInventory().getItem(packet.getSlot()))); - this.player.connection.send(new ClientboundSetCarriedItemPacket(this.player.getInventory().selected)); ++ ++ this.player.getInventory().pickSlot(event.getSourceSlot(), event.getTargetSlot()); // Paper - Add PlayerPickItemEvent + // Paper end - validate pick item position + int i = this.player.getInventory().selected; + diff --git a/src/main/java/net/minecraft/world/entity/player/Inventory.java b/src/main/java/net/minecraft/world/entity/player/Inventory.java index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/net/minecraft/world/entity/player/Inventory.java diff --git a/patches/server/Add-PrepareResultEvent.patch b/patches/server/Add-PrepareResultEvent.patch index 1c68591224..6ea5b1bee5 100644 --- a/patches/server/Add-PrepareResultEvent.patch +++ b/patches/server/Add-PrepareResultEvent.patch @@ -97,7 +97,7 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java +++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java -@@ -0,0 +0,0 @@ populateFields(victim, event); // Paper - make cancellable +@@ -0,0 +0,0 @@ public class CraftEventFactory { } public static PrepareAnvilEvent callPrepareAnvilEvent(AnvilView view, ItemStack item) { @@ -110,7 +110,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 PrepareAnvilEvent event = new PrepareAnvilEvent(view, CraftItemStack.asCraftMirror(item).clone()); event.getView().getPlayer().getServer().getPluginManager().callEvent(event); event.getInventory().setItem(2, event.getResult()); -@@ -0,0 +0,0 @@ populateFields(victim, event); // Paper - make cancellable +@@ -0,0 +0,0 @@ public class CraftEventFactory { } public static PrepareGrindstoneEvent callPrepareGrindstoneEvent(InventoryView view, ItemStack item) { @@ -123,7 +123,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 PrepareGrindstoneEvent event = new PrepareGrindstoneEvent(view, CraftItemStack.asCraftMirror(item).clone()); event.getView().getPlayer().getServer().getPluginManager().callEvent(event); event.getInventory().setItem(2, event.getResult()); -@@ -0,0 +0,0 @@ populateFields(victim, event); // Paper - make cancellable +@@ -0,0 +0,0 @@ public class CraftEventFactory { } public static PrepareSmithingEvent callPrepareSmithingEvent(InventoryView view, ItemStack item) { diff --git a/patches/unapplied/server/Add-Structure-check-API.patch b/patches/server/Add-Structure-check-API.patch similarity index 100% rename from patches/unapplied/server/Add-Structure-check-API.patch rename to patches/server/Add-Structure-check-API.patch diff --git a/patches/unapplied/server/Add-UUID-attribute-modifier-API.patch b/patches/server/Add-UUID-attribute-modifier-API.patch similarity index 100% rename from patches/unapplied/server/Add-UUID-attribute-modifier-API.patch rename to patches/server/Add-UUID-attribute-modifier-API.patch diff --git a/patches/server/Add-critical-damage-API.patch b/patches/server/Add-critical-damage-API.patch index 487f7e30fe..93b51c8d9a 100644 --- a/patches/server/Add-critical-damage-API.patch +++ b/patches/server/Add-critical-damage-API.patch @@ -64,7 +64,7 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java +++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java -@@ -0,0 +0,0 @@ populateFields(victim, event); // Paper - make cancellable +@@ -0,0 +0,0 @@ public class CraftEventFactory { return CraftEventFactory.callEntityDamageEvent(source.getDirectBlock(), source.getDirectBlockState(), entity, DamageCause.BLOCK_EXPLOSION, bukkitDamageSource, modifiers, modifierFunctions, cancelled); } DamageCause damageCause = (damager.getBukkitEntity() instanceof org.bukkit.entity.TNTPrimed) ? DamageCause.BLOCK_EXPLOSION : DamageCause.ENTITY_EXPLOSION; @@ -73,7 +73,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 } else if (damager != null || source.getDirectEntity() != null) { DamageCause cause = (source.isSweep()) ? DamageCause.ENTITY_SWEEP_ATTACK : DamageCause.ENTITY_ATTACK; -@@ -0,0 +0,0 @@ populateFields(victim, event); // Paper - make cancellable +@@ -0,0 +0,0 @@ public class CraftEventFactory { cause = DamageCause.MAGIC; } @@ -82,7 +82,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 } else if (source.is(DamageTypes.FELL_OUT_OF_WORLD)) { return CraftEventFactory.callEntityDamageEvent(source.getDirectBlock(), source.getDirectBlockState(), entity, DamageCause.VOID, bukkitDamageSource, modifiers, modifierFunctions, cancelled); } else if (source.is(DamageTypes.LAVA)) { -@@ -0,0 +0,0 @@ populateFields(victim, event); // Paper - make cancellable +@@ -0,0 +0,0 @@ public class CraftEventFactory { cause = DamageCause.CUSTOM; } diff --git a/patches/unapplied/server/Add-drops-to-shear-events.patch b/patches/server/Add-drops-to-shear-events.patch similarity index 50% rename from patches/unapplied/server/Add-drops-to-shear-events.patch rename to patches/server/Add-drops-to-shear-events.patch index 74c6004a1c..225f435d9d 100644 --- a/patches/unapplied/server/Add-drops-to-shear-events.patch +++ b/patches/server/Add-drops-to-shear-events.patch @@ -14,14 +14,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 // CraftBukkit start - if (CraftEventFactory.callBlockShearEntityEvent(entityliving, bukkitBlock, craftItem).isCancelled()) { + // Paper start - Add drops to shear events -+ org.bukkit.event.block.BlockShearEntityEvent event = CraftEventFactory.callBlockShearEntityEvent(entityliving, bukkitBlock, craftItem, ishearable.generateDefaultDrops()); ++ org.bukkit.event.block.BlockShearEntityEvent event = CraftEventFactory.callBlockShearEntityEvent(entityliving, bukkitBlock, craftItem, ishearable.generateDefaultDrops(worldserver, itemstack)); + if (event.isCancelled()) { + // Paper end - Add drops to shear events continue; } // CraftBukkit end -- ishearable.shear(SoundSource.BLOCKS); -+ ishearable.shear(SoundSource.BLOCKS, CraftItemStack.asNMSCopy(event.getDrops())); // Paper - Add drops to shear events +- ishearable.shear(worldserver, SoundSource.BLOCKS, itemstack); ++ ishearable.shear(worldserver, SoundSource.BLOCKS, itemstack, CraftItemStack.asNMSCopy(event.getDrops())); // Paper - Add drops to shear events worldserver.gameEvent((Entity) null, (Holder) GameEvent.SHEAR, blockposition); return true; } @@ -29,16 +29,16 @@ diff --git a/src/main/java/net/minecraft/world/entity/Shearable.java b/src/main/ index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/net/minecraft/world/entity/Shearable.java +++ b/src/main/java/net/minecraft/world/entity/Shearable.java -@@ -0,0 +0,0 @@ package net.minecraft.world.entity; - import net.minecraft.sounds.SoundSource; +@@ -0,0 +0,0 @@ import net.minecraft.sounds.SoundSource; + import net.minecraft.world.item.ItemStack; public interface Shearable { -+ default void shear(SoundSource soundCategory, java.util.List drops) { this.shear(soundCategory); } // Paper - Add drops to shear events - void shear(SoundSource shearedSoundCategory); ++ default void shear(ServerLevel world, SoundSource soundCategory, ItemStack shears, java.util.List drops) { this.shear(world, soundCategory, shears); } // Paper - Add drops to shear events + void shear(ServerLevel world, SoundSource shearedSoundCategory, ItemStack shears); boolean readyForShearing(); + // Paper start - custom shear drops; ensure all implementing entities override this -+ default java.util.List generateDefaultDrops() { ++ default java.util.List generateDefaultDrops(final ServerLevel serverLevel, final ItemStack shears) { + return java.util.Collections.emptyList(); + } + // Paper end - custom shear drops @@ -47,275 +47,262 @@ diff --git a/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java b/ index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java +++ b/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java +@@ -0,0 +0,0 @@ import net.minecraft.world.level.storage.loot.BuiltInLootTables; + // CraftBukkit start + import org.bukkit.Bukkit; + import org.bukkit.craftbukkit.event.CraftEventFactory; ++import org.bukkit.craftbukkit.inventory.CraftItemStack; + import org.bukkit.event.entity.EntityDropItemEvent; + import org.bukkit.event.entity.EntityTransformEvent; + // CraftBukkit end @@ -0,0 +0,0 @@ public class MushroomCow extends Cow implements Shearable, VariantHolder drops = this.generateDefaultDrops(); -+ org.bukkit.event.player.PlayerShearEntityEvent event = CraftEventFactory.handlePlayerShearEntityEvent(player, this, itemstack, hand, drops); -+ if (event != null) { -+ if (event.isCancelled()) { -+ return InteractionResult.PASS; -+ } -+ drops = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(event.getDrops()); - } -+ // Paper end - custom shear drops - // CraftBukkit end -- this.shear(SoundSource.PLAYERS); -+ this.shear(SoundSource.PLAYERS, drops); // Paper - custom shear drops - this.gameEvent(GameEvent.SHEAR, player); - if (!this.level().isClientSide) { - itemstack.hurtAndBreak(1, player, getSlotForHand(hand)); -@@ -0,0 +0,0 @@ public class MushroomCow extends Cow implements Shearable, VariantHolder generateDefaultDrops() { -+ java.util.List dropEntities = new java.util.ArrayList<>(5); -+ for (int i = 0; i < 5; ++i) { -+ dropEntities.add(new ItemStack(this.getVariant().getBlockState().getBlock())); -+ } -+ return dropEntities; -+ } -+ -+ @Override -+ public void shear(SoundSource shearedSoundCategory, java.util.List drops) { // If drops is null, need to generate drops -+ // Paper end - custom shear drops - this.level().playSound((Player) null, (Entity) this, SoundEvents.MOOSHROOM_SHEAR, shearedSoundCategory, 1.0F, 1.0F); - if (!this.level().isClientSide()) { - Cow entitycow = (Cow) EntityType.COW.create(this.level()); -@@ -0,0 +0,0 @@ public class MushroomCow extends Cow implements Shearable, VariantHolder drops = this.generateDefaultDrops(); ++ java.util.List drops = this.generateDefaultDrops(worldserver, itemstack); + org.bukkit.event.player.PlayerShearEntityEvent event = CraftEventFactory.handlePlayerShearEntityEvent(player, this, itemstack, hand, drops); + if (event != null) { + if (event.isCancelled()) { + return InteractionResult.PASS; + } + drops = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(event.getDrops()); - } + // Paper end - custom shear drops + } // CraftBukkit end -- this.shear(SoundSource.PLAYERS); -+ this.shear(SoundSource.PLAYERS, drops); // Paper +- this.shear(worldserver, SoundSource.PLAYERS, itemstack); ++ this.shear(worldserver, SoundSource.PLAYERS, itemstack, drops); // Paper - custom shear drops this.gameEvent(GameEvent.SHEAR, player); itemstack.hurtAndBreak(1, player, getSlotForHand(hand)); - return InteractionResult.SUCCESS; + } +@@ -0,0 +0,0 @@ public class MushroomCow extends Cow implements Shearable, VariantHolder generateDefaultDrops(final ServerLevel serverLevel, final ItemStack shears) { ++ final java.util.List drops = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); ++ this.dropFromShearingLootTable(serverLevel, BuiltInLootTables.SHEAR_MOOSHROOM, shears, (ignored, stack) -> { ++ for (int i = 0; i < stack.getCount(); ++i) drops.add(stack.copyWithCount(1)); ++ }); ++ return drops; ++ } ++ ++ @Override ++ public void shear(ServerLevel world, SoundSource shearedSoundCategory, ItemStack shears, java.util.List drops) { ++ // Paper end - custom shear drops + world.playSound((Player) null, (Entity) this, SoundEvents.MOOSHROOM_SHEAR, shearedSoundCategory, 1.0F, 1.0F); + this.convertTo(EntityType.COW, ConversionParams.single(this, false, false), (entitycow) -> { + world.sendParticles(ParticleTypes.EXPLOSION, this.getX(), this.getY(0.5D), this.getZ(), 1, 0.0D, 0.0D, 0.0D, 0.0D); +- this.dropFromShearingLootTable(world, BuiltInLootTables.SHEAR_MOOSHROOM, shears, (worldserver1, itemstack1) -> { +- for (int i = 0; i < itemstack1.getCount(); ++i) { +- // CraftBukkit start +- ItemEntity entityitem = new ItemEntity(this.level(), this.getX(), this.getY(1.0D), this.getZ(), itemstack1.copyWithCount(1)); +- EntityDropItemEvent event = new EntityDropItemEvent(this.getBukkitEntity(), (org.bukkit.entity.Item) entityitem.getBukkitEntity()); +- Bukkit.getPluginManager().callEvent(event); +- if (event.isCancelled()) { +- continue; +- } +- worldserver1.addFreshEntity(entityitem); +- // CraftBukkit end ++ // Paper start - custom shear drops; moved drop generation to separate method ++ drops.forEach(itemstack1 -> { ++ for (final ItemStack drop : drops) { ++ ItemEntity entityitem = new ItemEntity(this.level(), this.getX(), this.getY(1.0D), this.getZ(), drop); ++ this.spawnAtLocation(entityitem); + } +- ++ // Paper end - custom shear drops; moved drop generation to separate method + }); + }, EntityTransformEvent.TransformReason.SHEARED, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.SHEARED); // CraftBukkit + } +diff --git a/src/main/java/net/minecraft/world/entity/animal/Sheep.java b/src/main/java/net/minecraft/world/entity/animal/Sheep.java +index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Sheep.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Sheep.java +@@ -0,0 +0,0 @@ public class Sheep extends Animal implements Shearable { + + if (this.readyForShearing()) { + // CraftBukkit start +- if (!CraftEventFactory.handlePlayerShearEntityEvent(player, this, itemstack, hand)) { +- return InteractionResult.PASS; ++ // Paper start - custom shear drops ++ java.util.List drops = this.generateDefaultDrops(worldserver, itemstack); ++ org.bukkit.event.player.PlayerShearEntityEvent event = CraftEventFactory.handlePlayerShearEntityEvent(player, this, itemstack, hand, drops); ++ if (event != null) { ++ if (event.isCancelled()) { ++ return InteractionResult.PASS; ++ } ++ drops = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(event.getDrops()); ++ // Paper end - custom shear drops + } + // CraftBukkit end +- this.shear(worldserver, SoundSource.PLAYERS, itemstack); ++ this.shear(worldserver, SoundSource.PLAYERS, itemstack, drops); // Paper - custom shear drops + this.gameEvent(GameEvent.SHEAR, player); + itemstack.hurtAndBreak(1, player, getSlotForHand(hand)); + return InteractionResult.SUCCESS_SERVER; @@ -0,0 +0,0 @@ public class Sheep extends Animal implements Shearable { @Override - public void shear(SoundSource shearedSoundCategory) { + public void shear(ServerLevel world, SoundSource shearedSoundCategory, ItemStack shears) { + // Paper start - custom shear drops -+ this.shear(shearedSoundCategory, this.generateDefaultDrops()); ++ this.shear(world, shearedSoundCategory, shears, this.generateDefaultDrops(world, shears)); + } + + @Override -+ public java.util.List generateDefaultDrops() { -+ int count = 1 + this.random.nextInt(3); -+ java.util.List dropEntities = new java.util.ArrayList<>(count); -+ for (int j = 0; j < count; ++j) { -+ dropEntities.add(new ItemStack(Sheep.ITEM_BY_DYE.get(this.getColor()))); -+ } -+ return dropEntities; ++ public java.util.List generateDefaultDrops(final ServerLevel serverLevel, final ItemStack shears) { ++ final java.util.List drops = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); ++ this.dropFromShearingLootTable(serverLevel, BuiltInLootTables.SHEAR_SHEEP, shears, (ignored, stack) -> { ++ for (int i = 0; i < stack.getCount(); ++i) drops.add(stack.copyWithCount(1)); ++ }); ++ return drops; + } + + @Override -+ public void shear(SoundSource shearedSoundCategory, java.util.List drops) { ++ public void shear(ServerLevel world, SoundSource shearedSoundCategory, ItemStack shears, java.util.List drops) { ++ final ServerLevel worldserver1 = world; // Named for lambda consumption + // Paper end - custom shear drops - this.level().playSound((Player) null, (Entity) this, SoundEvents.SHEEP_SHEAR, shearedSoundCategory, 1.0F, 1.0F); - this.setSheared(true); - int i = 1 + this.random.nextInt(3); - -- for (int j = 0; j < i; ++j) { -+ for (final ItemStack drop : drops) { // Paper - custom shear drops (moved drop generation to separate method) - this.forceDrops = true; // CraftBukkit -- ItemEntity entityitem = this.spawnAtLocation((ItemLike) Sheep.ITEM_BY_DYE.get(this.getColor()), 1); -+ ItemEntity entityitem = this.spawnAtLocation(drop, 1); // Paper - custom shear drops - this.forceDrops = false; // CraftBukkit - - if (entityitem != null) { + world.playSound((Player) null, (Entity) this, SoundEvents.SHEEP_SHEAR, shearedSoundCategory, 1.0F, 1.0F); +- this.dropFromShearingLootTable(world, BuiltInLootTables.SHEAR_SHEEP, shears, (worldserver1, itemstack1) -> { +- for (int i = 0; i < itemstack1.getCount(); ++i) { ++ drops.forEach(itemstack1 -> { // Paper - custom drops - loop in generated default drops ++ if (true) { // Paper - custom drops - loop in generated default drops + this.forceDrops = true; // CraftBukkit + ItemEntity entityitem = this.spawnAtLocation(worldserver1, itemstack1.copyWithCount(1), 1.0F); + this.forceDrops = false; // CraftBukkit diff --git a/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java b/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java +++ b/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java @@ -0,0 +0,0 @@ public class SnowGolem extends AbstractGolem implements Shearable, RangedAttackM + ServerLevel worldserver = (ServerLevel) world; - if (itemstack.is(Items.SHEARS) && this.readyForShearing()) { - // CraftBukkit start -- if (!CraftEventFactory.handlePlayerShearEntityEvent(player, this, itemstack, hand)) { -- return InteractionResult.PASS; -+ // Paper start - custom shear drops -+ java.util.List drops = this.generateDefaultDrops(); -+ org.bukkit.event.player.PlayerShearEntityEvent event = CraftEventFactory.handlePlayerShearEntityEvent(player, this, itemstack, hand, drops); -+ if (event != null) { -+ if (event.isCancelled()) { -+ return InteractionResult.PASS; -+ } -+ drops = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(event.getDrops()); - } -+ // Paper end - custom shear drops - // CraftBukkit end -- this.shear(SoundSource.PLAYERS); -+ this.shear(SoundSource.PLAYERS, drops); // Paper - this.gameEvent(GameEvent.SHEAR, player); - if (!this.level().isClientSide) { + // CraftBukkit start +- if (!CraftEventFactory.handlePlayerShearEntityEvent(player, this, itemstack, hand)) { +- return InteractionResult.PASS; ++ // Paper start - custom shear drops ++ java.util.List drops = this.generateDefaultDrops(worldserver, itemstack); ++ org.bukkit.event.player.PlayerShearEntityEvent event = CraftEventFactory.handlePlayerShearEntityEvent(player, this, itemstack, hand, drops); ++ if (event != null) { ++ if (event.isCancelled()) { ++ return InteractionResult.PASS; ++ } ++ drops = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(event.getDrops()); ++ // Paper end - custom shear drops + } + // CraftBukkit end +- this.shear(worldserver, SoundSource.PLAYERS, itemstack); ++ this.shear(worldserver, SoundSource.PLAYERS, itemstack, drops); // Paper - custom shear drops + this.gameEvent(GameEvent.SHEAR, player); itemstack.hurtAndBreak(1, player, getSlotForHand(hand)); + } @@ -0,0 +0,0 @@ public class SnowGolem extends AbstractGolem implements Shearable, RangedAttackM @Override - public void shear(SoundSource shearedSoundCategory) { -+ // Paper start - custom shear drops -+ this.shear(shearedSoundCategory, this.generateDefaultDrops()); + public void shear(ServerLevel world, SoundSource shearedSoundCategory, ItemStack shears) { ++ // Paper start - custom shear drops ++ this.shear(world, shearedSoundCategory, shears, this.generateDefaultDrops(world, shears)); + } + + @Override -+ public java.util.List generateDefaultDrops() { -+ return java.util.Collections.singletonList(new ItemStack(Items.CARVED_PUMPKIN)); ++ public java.util.List generateDefaultDrops(final ServerLevel serverLevel, final ItemStack shears) { ++ final java.util.List drops = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); ++ this.dropFromShearingLootTable(serverLevel, BuiltInLootTables.SHEAR_SNOW_GOLEM, shears, (ignored, stack) -> { ++ drops.add(stack); ++ }); ++ return drops; + } + + @Override -+ public void shear(SoundSource shearedSoundCategory, java.util.List drops) { -+ // Paper end - custom shear drops - this.level().playSound((Player) null, (Entity) this, SoundEvents.SNOW_GOLEM_SHEAR, shearedSoundCategory, 1.0F, 1.0F); - if (!this.level().isClientSide()) { - this.setPumpkin(false); -- this.forceDrops = true; // CraftBukkit -- this.spawnAtLocation(new ItemStack(Items.CARVED_PUMPKIN), this.getEyeHeight()); -- this.forceDrops = false; // CraftBukkit -+ // Paper start - custom shear drops (moved drop generation to separate method) -+ for (final ItemStack drop : drops) { -+ this.forceDrops = true; -+ this.spawnAtLocation(drop, this.getEyeHeight()); -+ this.forceDrops = false; -+ } -+ // Paper end - custom shear drops - } - - } ++ public void shear(ServerLevel world, SoundSource shearedSoundCategory, ItemStack shears, java.util.List drops) { ++ final ServerLevel worldserver1 = world; // Named for lambda consumption ++ // Paper end - custom shear drops + world.playSound((Player) null, (Entity) this, SoundEvents.SNOW_GOLEM_SHEAR, shearedSoundCategory, 1.0F, 1.0F); + this.setPumpkin(false); +- this.dropFromShearingLootTable(world, BuiltInLootTables.SHEAR_SNOW_GOLEM, shears, (worldserver1, itemstack1) -> { ++ drops.forEach(itemstack1 -> { // Paper - custom shear drops + this.forceDrops = true; // CraftBukkit + this.spawnAtLocation(worldserver1, itemstack1, this.getEyeHeight()); + this.forceDrops = false; // CraftBukkit diff --git a/src/main/java/net/minecraft/world/entity/monster/Bogged.java b/src/main/java/net/minecraft/world/entity/monster/Bogged.java index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/net/minecraft/world/entity/monster/Bogged.java +++ b/src/main/java/net/minecraft/world/entity/monster/Bogged.java -@@ -0,0 +0,0 @@ public class Bogged extends AbstractSkeleton implements Shearable { +@@ -0,0 +0,0 @@ import net.minecraft.world.item.Items; + import net.minecraft.world.level.Level; + import net.minecraft.world.level.gameevent.GameEvent; + import net.minecraft.world.level.storage.loot.BuiltInLootTables; ++import org.bukkit.craftbukkit.event.CraftEventFactory; - if (itemstack.is(Items.SHEARS) && this.readyForShearing()) { - // CraftBukkit start -- if (!org.bukkit.craftbukkit.event.CraftEventFactory.handlePlayerShearEntityEvent(player, this, itemstack, hand)) { -- this.getEntityData().markDirty(Bogged.DATA_SHEARED); // CraftBukkit - mark dirty to restore sheared state to clients -- return InteractionResult.PASS; -+ // Paper start - expose drops in event -+ java.util.List drops = generateDefaultDrops(); -+ final org.bukkit.event.player.PlayerShearEntityEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.handlePlayerShearEntityEvent(player, this, itemstack, hand, drops); -+ if (event != null) { -+ if (event.isCancelled()) { -+ if (player instanceof final net.minecraft.server.level.ServerPlayer serverPlayer) this.resendPossiblyDesyncedDataValues(java.util.List.of(Bogged.DATA_SHEARED), serverPlayer); -+ return InteractionResult.PASS; -+ } -+ drops = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(event.getDrops()); -+ // Paper end - expose drops in event - } - // CraftBukkit end -- this.shear(SoundSource.PLAYERS); -+ this.shear(SoundSource.PLAYERS, drops); // Paper - expose drops in event - this.gameEvent(GameEvent.SHEAR, player); - if (!this.level().isClientSide) { + public class Bogged extends AbstractSkeleton implements Shearable { + +@@ -0,0 +0,0 @@ public class Bogged extends AbstractSkeleton implements Shearable { + ServerLevel worldserver = (ServerLevel) world; + + // CraftBukkit start +- if (!org.bukkit.craftbukkit.event.CraftEventFactory.handlePlayerShearEntityEvent(player, this, itemstack, hand)) { +- this.getEntityData().markDirty(Bogged.DATA_SHEARED); // CraftBukkit - mark dirty to restore sheared state to clients +- return InteractionResult.PASS; ++ // Paper start - custom shear drops ++ java.util.List drops = this.generateDefaultDrops(worldserver, itemstack); ++ org.bukkit.event.player.PlayerShearEntityEvent event = CraftEventFactory.handlePlayerShearEntityEvent(player, this, itemstack, hand, drops); ++ if (event != null) { ++ if (event.isCancelled()) { ++ this.getEntityData().markDirty(Bogged.DATA_SHEARED); // CraftBukkit - mark dirty to restore sheared state to clients ++ return InteractionResult.PASS; ++ } ++ drops = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(event.getDrops()); ++ // Paper end - custom shear drops + } + // CraftBukkit end +- this.shear(worldserver, SoundSource.PLAYERS, itemstack); ++ this.shear(worldserver, SoundSource.PLAYERS, itemstack, drops); // Paper - custom shear drops + this.gameEvent(GameEvent.SHEAR, player); itemstack.hurtAndBreak(1, player, getSlotForHand(hand)); + } @@ -0,0 +0,0 @@ public class Bogged extends AbstractSkeleton implements Shearable { @Override - public void shear(SoundSource shearedSoundCategory) { -+ // Paper start - shear drop API -+ this.shear(shearedSoundCategory, generateDefaultDrops()); + public void shear(ServerLevel world, SoundSource shearedSoundCategory, ItemStack shears) { ++ // Paper start - custom shear drops ++ this.shear(world, shearedSoundCategory, shears, this.generateDefaultDrops(world, shears)); + } + + @Override -+ public void shear(SoundSource shearedSoundCategory, java.util.List drops) { -+ // Paper end - shear drop API - this.level().playSound((Player) null, (Entity) this, SoundEvents.BOGGED_SHEAR, shearedSoundCategory, 1.0F, 1.0F); -- this.spawnShearedMushrooms(); -+ this.spawnDrops(drops); // Paper - shear drop API ++ public java.util.List generateDefaultDrops(final ServerLevel serverLevel, final ItemStack shears) { ++ final java.util.List drops = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); ++ this.dropFromShearingLootTable(serverLevel, BuiltInLootTables.BOGGED_SHEAR, shears, (ignored, stack) -> { ++ drops.add(stack); ++ }); ++ return drops; ++ } ++ ++ @Override ++ public void shear(ServerLevel world, SoundSource shearedSoundCategory, ItemStack shears, java.util.List drops) { ++ // Paper end - custom shear drops + world.playSound((Player) null, (Entity) this, SoundEvents.BOGGED_SHEAR, shearedSoundCategory, 1.0F, 1.0F); +- this.spawnShearedMushrooms(world, shears); ++ this.spawnShearedMushrooms(world, shears, drops); // Paper - custom shear drops this.setSheared(true); } - private void spawnShearedMushrooms() { -+ // Paper start - shear drops API -+ this.spawnDrops(generateDefaultDrops()); // Only here for people calling spawnSheardMushrooms. Not used otherwise. -+ } -+ private void spawnDrops(java.util.List drops) { -+ drops.forEach(stack -> { -+ this.forceDrops = true; -+ this.spawnAtLocation(stack, this.getBbHeight()); -+ this.forceDrops = false; -+ }); -+ } -+ private void generateShearedMushrooms(java.util.function.Consumer stackConsumer) { -+ // Paper end - shear drops API - Level world = this.level(); - - if (world instanceof ServerLevel worldserver) { -@@ -0,0 +0,0 @@ public class Bogged extends AbstractSkeleton implements Shearable { - while (objectlistiterator.hasNext()) { - ItemStack itemstack = (ItemStack) objectlistiterator.next(); - -- this.spawnAtLocation(itemstack, this.getBbHeight()); -+ stackConsumer.accept(itemstack); // Paper - } - } - +- private void spawnShearedMushrooms(ServerLevel world, ItemStack shears) { +- this.dropFromShearingLootTable(world, BuiltInLootTables.BOGGED_SHEAR, shears, (worldserver1, itemstack1) -> { ++ // Paper start - custom shear drops ++ private void spawnShearedMushrooms(ServerLevel world, ItemStack shears, java.util.List drops) { ++ final ServerLevel worldserver1 = world; // Named for lambda consumption ++ drops.forEach(itemstack1 -> { ++ // Paper end - custom shear drops + this.spawnAtLocation(worldserver1, itemstack1, this.getBbHeight()); + }); } - -+ // Paper start - shear drops API -+ @Override -+ public java.util.List generateDefaultDrops() { -+ final java.util.List drops = new java.util.ArrayList<>(); -+ this.generateShearedMushrooms(drops::add); -+ return drops; -+ } -+ // Paper end - shear drops API -+ - @Override - public boolean readyForShearing() { - return !this.isSheared() && this.isAlive(); diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java diff --git a/patches/unapplied/server/Add-experience-points-API.patch b/patches/server/Add-experience-points-API.patch similarity index 100% rename from patches/unapplied/server/Add-experience-points-API.patch rename to patches/server/Add-experience-points-API.patch diff --git a/patches/unapplied/server/Add-hand-to-fish-event-for-all-player-interactions.patch b/patches/server/Add-hand-to-fish-event-for-all-player-interactions.patch similarity index 100% rename from patches/unapplied/server/Add-hand-to-fish-event-for-all-player-interactions.patch rename to patches/server/Add-hand-to-fish-event-for-all-player-interactions.patch diff --git a/patches/unapplied/server/Add-missing-InventoryHolders-to-inventories.patch b/patches/server/Add-missing-InventoryHolders-to-inventories.patch similarity index 94% rename from patches/unapplied/server/Add-missing-InventoryHolders-to-inventories.patch rename to patches/server/Add-missing-InventoryHolders-to-inventories.patch index 71e6275c06..3aed3e68b5 100644 --- a/patches/unapplied/server/Add-missing-InventoryHolders-to-inventories.patch +++ b/patches/server/Add-missing-InventoryHolders-to-inventories.patch @@ -180,28 +180,40 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 --- a/src/main/java/net/minecraft/world/inventory/ItemCombinerMenu.java +++ b/src/main/java/net/minecraft/world/inventory/ItemCombinerMenu.java @@ -0,0 +0,0 @@ public abstract class ItemCombinerMenu extends AbstractContainerMenu { + protected final ContainerLevelAccess access; protected final Player player; protected final Container inputSlots; - private final List inputSlotIndexes; -- protected final ResultContainer resultSlots = new ResultContainer(); +- protected final ResultContainer resultSlots = new ResultContainer() { +- @Override +- public void setChanged() { +- ItemCombinerMenu.this.slotsChanged(this); +- } +- }; + protected final ResultContainer resultSlots; // Paper - Add missing InventoryHolders; delay field init private final int resultSlotIndex; - protected abstract boolean mayPickup(Player player, boolean present); + protected boolean mayPickup(Player player, boolean present) { @@ -0,0 +0,0 @@ public abstract class ItemCombinerMenu extends AbstractContainerMenu { - public ItemCombinerMenu(@Nullable MenuType type, int syncId, Inventory playerInventory, ContainerLevelAccess context) { + public ItemCombinerMenu(@Nullable MenuType type, int syncId, Inventory playerInventory, ContainerLevelAccess context, ItemCombinerMenuSlotDefinition forgingSlotsManager) { super(type, syncId); this.access = context; -+ this.resultSlots = new ResultContainer(this.createBlockHolder(this.access)); // Paper - Add missing InventoryHolders; delay field init ++ // Paper start - Add missing InventoryHolders; delay field init ++ this.resultSlots = new ResultContainer(this.createBlockHolder(this.access)) { ++ @Override ++ public void setChanged() { ++ ItemCombinerMenu.this.slotsChanged(this); ++ } ++ }; ++ // Paper end - Add missing InventoryHolders; delay field init this.player = playerInventory.player; - ItemCombinerMenuSlotDefinition itemcombinermenuslotdefinition = this.createInputSlotDefinitions(); - + this.inputSlots = this.createContainer(forgingSlotsManager.getNumOfInputSlots()); + this.resultSlotIndex = forgingSlotsManager.getResultSlotIndex(); @@ -0,0 +0,0 @@ public abstract class ItemCombinerMenu extends AbstractContainerMenu { - protected abstract ItemCombinerMenuSlotDefinition createInputSlotDefinitions(); + public abstract void createResult(); private SimpleContainer createContainer(int size) { - return new SimpleContainer(size) { -+ return new SimpleContainer(this.createBlockHolder(this.access), size) { // Paper - Add missing InventoryHolders ++ return new SimpleContainer(this.createBlockHolder(this.access), size) { @Override public void setChanged() { super.setChanged(); diff --git a/patches/unapplied/server/Add-missing-logs-for-log-ips-config-option.patch b/patches/server/Add-missing-logs-for-log-ips-config-option.patch similarity index 100% rename from patches/unapplied/server/Add-missing-logs-for-log-ips-config-option.patch rename to patches/server/Add-missing-logs-for-log-ips-config-option.patch diff --git a/patches/unapplied/server/Add-player-idle-duration-API.patch b/patches/server/Add-player-idle-duration-API.patch similarity index 100% rename from patches/unapplied/server/Add-player-idle-duration-API.patch rename to patches/server/Add-player-idle-duration-API.patch diff --git a/patches/unapplied/server/Add-predicate-for-blocks-when-raytracing.patch b/patches/server/Add-predicate-for-blocks-when-raytracing.patch similarity index 100% rename from patches/unapplied/server/Add-predicate-for-blocks-when-raytracing.patch rename to patches/server/Add-predicate-for-blocks-when-raytracing.patch diff --git a/patches/unapplied/server/Add-slot-sanity-checks-in-container-clicks.patch b/patches/server/Add-slot-sanity-checks-in-container-clicks.patch similarity index 100% rename from patches/unapplied/server/Add-slot-sanity-checks-in-container-clicks.patch rename to patches/server/Add-slot-sanity-checks-in-container-clicks.patch diff --git a/patches/unapplied/server/Add-titleOverride-to-InventoryOpenEvent.patch b/patches/server/Add-titleOverride-to-InventoryOpenEvent.patch similarity index 100% rename from patches/unapplied/server/Add-titleOverride-to-InventoryOpenEvent.patch rename to patches/server/Add-titleOverride-to-InventoryOpenEvent.patch diff --git a/patches/unapplied/server/Allow-null-itemstack-for-Player-sendEquipmentChange.patch b/patches/server/Allow-null-itemstack-for-Player-sendEquipmentChange.patch similarity index 100% rename from patches/unapplied/server/Allow-null-itemstack-for-Player-sendEquipmentChange.patch rename to patches/server/Allow-null-itemstack-for-Player-sendEquipmentChange.patch diff --git a/patches/unapplied/server/Allow-proper-checking-of-empty-item-stacks.patch b/patches/server/Allow-proper-checking-of-empty-item-stacks.patch similarity index 100% rename from patches/unapplied/server/Allow-proper-checking-of-empty-item-stacks.patch rename to patches/server/Allow-proper-checking-of-empty-item-stacks.patch diff --git a/patches/unapplied/server/Allow-trident-custom-damage.patch b/patches/server/Allow-trident-custom-damage.patch similarity index 100% rename from patches/unapplied/server/Allow-trident-custom-damage.patch rename to patches/server/Allow-trident-custom-damage.patch diff --git a/patches/unapplied/server/Broadcast-take-item-packets-with-collector-as-source.patch b/patches/server/Broadcast-take-item-packets-with-collector-as-source.patch similarity index 100% rename from patches/unapplied/server/Broadcast-take-item-packets-with-collector-as-source.patch rename to patches/server/Broadcast-take-item-packets-with-collector-as-source.patch diff --git a/patches/unapplied/server/Call-BlockRedstoneEvents-for-lecterns.patch b/patches/server/Call-BlockRedstoneEvents-for-lecterns.patch similarity index 100% rename from patches/unapplied/server/Call-BlockRedstoneEvents-for-lecterns.patch rename to patches/server/Call-BlockRedstoneEvents-for-lecterns.patch diff --git a/patches/server/Call-missing-BlockDispenseEvent.patch b/patches/server/Call-missing-BlockDispenseEvent.patch index ff5a9b3127..177d9db68a 100644 --- a/patches/server/Call-missing-BlockDispenseEvent.patch +++ b/patches/server/Call-missing-BlockDispenseEvent.patch @@ -53,7 +53,7 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java +++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java -@@ -0,0 +0,0 @@ populateFields(victim, event); // Paper - make cancellable +@@ -0,0 +0,0 @@ public class CraftEventFactory { } // Paper end diff --git a/patches/unapplied/server/Configure-sniffer-egg-hatch-time.patch b/patches/server/Configure-sniffer-egg-hatch-time.patch similarity index 100% rename from patches/unapplied/server/Configure-sniffer-egg-hatch-time.patch rename to patches/server/Configure-sniffer-egg-hatch-time.patch diff --git a/patches/unapplied/server/Do-crystal-portal-proximity-check-before-entity-look.patch b/patches/server/Do-crystal-portal-proximity-check-before-entity-look.patch similarity index 100% rename from patches/unapplied/server/Do-crystal-portal-proximity-check-before-entity-look.patch rename to patches/server/Do-crystal-portal-proximity-check-before-entity-look.patch diff --git a/patches/unapplied/server/Do-not-read-tile-entities-in-chunks-that-are-positio.patch b/patches/server/Do-not-read-tile-entities-in-chunks-that-are-positio.patch similarity index 51% rename from patches/unapplied/server/Do-not-read-tile-entities-in-chunks-that-are-positio.patch rename to patches/server/Do-not-read-tile-entities-in-chunks-that-are-positio.patch index 8b1a5b998c..0ddcd25eb9 100644 --- a/patches/unapplied/server/Do-not-read-tile-entities-in-chunks-that-are-positio.patch +++ b/patches/server/Do-not-read-tile-entities-in-chunks-that-are-positio.patch @@ -9,42 +9,35 @@ This can happen as a result of users moving regionfiles around, which would cause a crash on Folia but would appear to function fine on Paper. -diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java +diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/SerializableChunkData.java b/src/main/java/net/minecraft/world/level/chunk/storage/SerializableChunkData.java index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 ---- a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java -+++ b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java -@@ -0,0 +0,0 @@ public class ChunkSerializer { - for (int k1 = 0; k1 < nbttaglist3.size(); ++k1) { - CompoundTag nbttagcompound4 = nbttaglist3.getCompound(k1); +--- a/src/main/java/net/minecraft/world/level/chunk/storage/SerializableChunkData.java ++++ b/src/main/java/net/minecraft/world/level/chunk/storage/SerializableChunkData.java +@@ -0,0 +0,0 @@ public record SerializableChunkData(Registry biomeRegistry, ChunkPos chun + while (iterator2.hasNext()) { + nbttagcompound = (CompoundTag) iterator2.next(); + // Paper start - do not read tile entities positioned outside the chunk -+ BlockPos blockposition = BlockEntity.getPosFromTag(nbttagcompound4); ++ final BlockPos blockposition = BlockEntity.getPosFromTag(nbttagcompound); + if ((blockposition.getX() >> 4) != chunkPos.x || (blockposition.getZ() >> 4) != chunkPos.z) { -+ LOGGER.warn("Tile entity serialized in chunk " + chunkPos + " in world '" + world.getWorld().getName() + "' positioned at " + blockposition + " is located outside of the chunk"); ++ LOGGER.warn("Tile entity serialized in chunk {} in world '{}' positioned at {} is located outside of the chunk", chunkPos, world.getWorld().getName(), blockposition); + continue; + } + // Paper end - do not read tile entities positioned outside the chunk - ((ChunkAccess) object1).setBlockEntityNbt(nbttagcompound4); + protochunk1.setBlockEntityNbt(nbttagcompound); } -@@ -0,0 +0,0 @@ public class ChunkSerializer { - CompoundTag nbttagcompound1 = nbttaglist1.getCompound(i); - boolean flag = nbttagcompound1.getBoolean("keepPacked"); - +@@ -0,0 +0,0 @@ public record SerializableChunkData(Registry biomeRegistry, ChunkPos chun + chunk.setBlockEntityNbt(nbttagcompound); + } else { + BlockPos blockposition = BlockEntity.getPosFromTag(nbttagcompound); + // Paper start - do not read tile entities positioned outside the chunk -+ BlockPos blockposition = BlockEntity.getPosFromTag(nbttagcompound1); // moved up + ChunkPos chunkPos = chunk.getPos(); + if ((blockposition.getX() >> 4) != chunkPos.x || (blockposition.getZ() >> 4) != chunkPos.z) { + LOGGER.warn("Tile entity serialized in chunk " + chunkPos + " in world '" + world.getWorld().getName() + "' positioned at " + blockposition + " is located outside of the chunk"); + continue; + } + // Paper end - do not read tile entities positioned outside the chunk -+ - if (flag) { - chunk.setBlockEntityNbt(nbttagcompound1); - } else { -- BlockPos blockposition = BlockEntity.getPosFromTag(nbttagcompound1); -+ // Paper - do not read tile entities positioned outside the chunk; move up - BlockEntity tileentity = BlockEntity.loadStatic(blockposition, chunk.getBlockState(blockposition), nbttagcompound1, world.registryAccess()); + BlockEntity tileentity = BlockEntity.loadStatic(blockposition, chunk.getBlockState(blockposition), nbttagcompound, world.registryAccess()); - if (tileentity != null) { + if (tileentity != null) { diff --git a/patches/unapplied/server/Don-t-check-if-we-can-see-non-visible-entities.patch b/patches/server/Don-t-check-if-we-can-see-non-visible-entities.patch similarity index 100% rename from patches/unapplied/server/Don-t-check-if-we-can-see-non-visible-entities.patch rename to patches/server/Don-t-check-if-we-can-see-non-visible-entities.patch diff --git a/patches/unapplied/server/Don-t-fire-sync-events-during-worldgen.patch b/patches/server/Don-t-fire-sync-events-during-worldgen.patch similarity index 92% rename from patches/unapplied/server/Don-t-fire-sync-events-during-worldgen.patch rename to patches/server/Don-t-fire-sync-events-during-worldgen.patch index d57c3fb213..d0661c4ec8 100644 --- a/patches/unapplied/server/Don-t-fire-sync-events-during-worldgen.patch +++ b/patches/server/Don-t-fire-sync-events-during-worldgen.patch @@ -22,7 +22,7 @@ diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/mai index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java -@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe // CraftBukkit start private boolean addEntity(Entity entity, CreatureSpawnEvent.SpawnReason spawnReason) { org.spigotmc.AsyncCatcher.catchOp("entity add"); // Spigot @@ -54,14 +54,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 @@ -0,0 +0,0 @@ public class EntityType implements FeatureElement, EntityTypeT } - public static Optional create(CompoundTag nbt, Level world) { -+ // Paper start - Don't fire sync event during generation + public static Optional create(CompoundTag nbt, Level world, EntitySpawnReason reason) { ++ // Paper start - Don't fire sync event during generation + return create(nbt, world, false); + } -+ public static Optional create(CompoundTag nbt, Level world, boolean generation) { -+ // Paper end - Don't fire sync event during generation ++ public static Optional create(CompoundTag nbt, Level world, EntitySpawnReason reason, boolean generation) { ++ // Paper end - Don't fire sync event during generation return Util.ifElse(EntityType.by(nbt).map((entitytypes) -> { - return entitytypes.create(world); + return entitytypes.create(world, reason); }), (entity) -> { + if (generation) entity.generation = true; // Paper - Don't fire sync event during generation entity.load(nbt); @@ -127,8 +127,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 private static Optional createEntityIgnoreException(ServerLevelAccessor world, CompoundTag nbt) { // CraftBukkit start // try { -- return EntityType.create(nbt, world.getLevel()); -+ return EntityType.create(nbt, world.getLevel(), true); // Paper - Don't fire sync event during generation +- return EntityType.create(nbt, world.getLevel(), EntitySpawnReason.STRUCTURE); ++ return EntityType.create(nbt, world.getLevel(), EntitySpawnReason.STRUCTURE, true); // Paper - Don't fire sync event during generation // } catch (Exception exception) { // return Optional.empty(); // } @@ -140,26 +140,26 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 return this.handle.getLevel(); } -- @Override -- public void addFreshEntityWithPassengers(Entity arg0, CreatureSpawnEvent.SpawnReason arg1) { -- this.handle.addFreshEntityWithPassengers(arg0, arg1); -- } -- - @Override - public void addFreshEntityWithPassengers(Entity entity) { - this.handle.addFreshEntityWithPassengers(entity); - } +- +- @Override +- public void addFreshEntityWithPassengers(Entity entity, CreatureSpawnEvent.SpawnReason reason) { +- this.handle.addFreshEntityWithPassengers(entity, reason); +- } + // Paper start - Don't fire sync event during generation; don't override these methods so all entities are run through addFreshEntity + // @Override -+ // public void addFreshEntityWithPassengers(Entity arg0, CreatureSpawnEvent.SpawnReason arg1) { -+ // this.handle.addFreshEntityWithPassengers(arg0, arg1); -+ // } -+ // -+ // @Override + // public void addFreshEntityWithPassengers(Entity entity) { + // this.handle.addFreshEntityWithPassengers(entity); + // } -+ // Paper end - Don't fire sync event during generation; don't override these methods ++ // ++ // @Override ++ // public void addFreshEntityWithPassengers(Entity entity, CreatureSpawnEvent.SpawnReason reason) { ++ // this.handle.addFreshEntityWithPassengers(entity, reason); ++ // } ++ // Paper end - Don't fire sync event during generation; don't override these methods so all entities are run through addFreshEntity @Override public ServerLevel getMinecraftWorld() { diff --git a/patches/unapplied/server/Dont-resend-blocks-on-interactions.patch b/patches/server/Dont-resend-blocks-on-interactions.patch similarity index 91% rename from patches/unapplied/server/Dont-resend-blocks-on-interactions.patch rename to patches/server/Dont-resend-blocks-on-interactions.patch index 34b6f42eb8..f109c93ca8 100644 --- a/patches/unapplied/server/Dont-resend-blocks-on-interactions.patch +++ b/patches/server/Dont-resend-blocks-on-interactions.patch @@ -137,7 +137,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 - ((ServerPlayer) user).connection.send(new ClientboundBlockUpdatePacket(world, blockposition)); // SPIGOT-5163 (see PlayerInteractManager) + // ((ServerPlayer) user).connection.send(new ClientboundBlockUpdatePacket(world, blockposition)); // SPIGOT-5163 (see PlayerInteractManager) // Paper - Don't resend blocks ((ServerPlayer) user).getBukkitEntity().updateInventory(); // SPIGOT-4541 - return InteractionResultHolder.fail(itemstack); + return InteractionResult.FAIL; } @@ -0,0 +0,0 @@ public class BucketItem extends Item implements DispensibleContainerItem { if (flag2 && entityhuman != null) { @@ -153,19 +153,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 --- a/src/main/java/net/minecraft/world/item/ItemStack.java +++ b/src/main/java/net/minecraft/world/item/ItemStack.java @@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder { - world.preventPoiUpdated = false; + world.preventPoiUpdated = false; - // Brute force all possible updates -- BlockPos placedPos = ((CraftBlock) placeEvent.getBlock()).getPosition(); -- for (Direction dir : Direction.values()) { -- ((ServerPlayer) entityhuman).connection.send(new ClientboundBlockUpdatePacket(world, placedPos.relative(dir))); -- } -+ // 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. + // Brute force all possible updates +- BlockPos placedPos = ((CraftBlock) placeEvent.getBlock()).getPosition(); +- for (Direction dir : Direction.values()) { +- ((ServerPlayer) entityhuman).connection.send(new ClientboundBlockUpdatePacket(world, placedPos.relative(dir))); +- } ++ // 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. diff --git a/patches/server/Expand-EntityUnleashEvent.patch b/patches/server/Expand-EntityUnleashEvent.patch index 8aa9aadc8c..44a0e6cd51 100644 --- a/patches/server/Expand-EntityUnleashEvent.patch +++ b/patches/server/Expand-EntityUnleashEvent.patch @@ -142,7 +142,7 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java +++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java -@@ -0,0 +0,0 @@ populateFields(victim, event); // Paper - make cancellable +@@ -0,0 +0,0 @@ public class CraftEventFactory { Bukkit.getPluginManager().callEvent(new PlayerRecipeBookSettingsChangeEvent(player.getBukkitEntity(), bukkitType, open, filter)); } diff --git a/patches/unapplied/server/Expand-LingeringPotion-API.patch b/patches/server/Expand-LingeringPotion-API.patch similarity index 98% rename from patches/unapplied/server/Expand-LingeringPotion-API.patch rename to patches/server/Expand-LingeringPotion-API.patch index f0b81414fd..9f9ce34494 100644 --- a/patches/unapplied/server/Expand-LingeringPotion-API.patch +++ b/patches/server/Expand-LingeringPotion-API.patch @@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/projectile/ThrownPotion.ja index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/net/minecraft/world/entity/projectile/ThrownPotion.java +++ b/src/main/java/net/minecraft/world/entity/projectile/ThrownPotion.java -@@ -0,0 +0,0 @@ public class ThrownPotion extends ThrowableItemProjectile implements ItemSupplie +@@ -0,0 +0,0 @@ public class ThrownPotion extends ThrowableItemProjectile { boolean noEffects = potioncontents.hasEffects(); // Paper - Fix potions splash events // CraftBukkit start org.bukkit.event.entity.LingeringPotionSplashEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callLingeringPotionSplashEvent(this, position, entityareaeffectcloud); diff --git a/patches/server/Expand-PlayerItemMendEvent.patch b/patches/server/Expand-PlayerItemMendEvent.patch index e3c1368d25..ceb80423e7 100644 --- a/patches/server/Expand-PlayerItemMendEvent.patch +++ b/patches/server/Expand-PlayerItemMendEvent.patch @@ -52,7 +52,7 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java +++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java -@@ -0,0 +0,0 @@ populateFields(victim, event); // Paper - make cancellable +@@ -0,0 +0,0 @@ public class CraftEventFactory { return event; } diff --git a/patches/unapplied/server/Expose-hand-in-BlockCanBuildEvent.patch b/patches/server/Expose-hand-in-BlockCanBuildEvent.patch similarity index 100% rename from patches/unapplied/server/Expose-hand-in-BlockCanBuildEvent.patch rename to patches/server/Expose-hand-in-BlockCanBuildEvent.patch diff --git a/patches/unapplied/server/Fix-CraftMetaItem-getAttributeModifier-duplication-c.patch b/patches/server/Fix-CraftMetaItem-getAttributeModifier-duplication-c.patch similarity index 100% rename from patches/unapplied/server/Fix-CraftMetaItem-getAttributeModifier-duplication-c.patch rename to patches/server/Fix-CraftMetaItem-getAttributeModifier-duplication-c.patch diff --git a/patches/unapplied/server/Fix-NPE-in-AdvancementProgress-getDateAwarded.patch b/patches/server/Fix-NPE-in-AdvancementProgress-getDateAwarded.patch similarity index 100% rename from patches/unapplied/server/Fix-NPE-in-AdvancementProgress-getDateAwarded.patch rename to patches/server/Fix-NPE-in-AdvancementProgress-getDateAwarded.patch diff --git a/patches/unapplied/server/Fix-NPE-in-SculkBloomEvent-world-access.patch b/patches/server/Fix-NPE-in-SculkBloomEvent-world-access.patch similarity index 100% rename from patches/unapplied/server/Fix-NPE-in-SculkBloomEvent-world-access.patch rename to patches/server/Fix-NPE-in-SculkBloomEvent-world-access.patch diff --git a/patches/unapplied/server/Fix-NPE-on-null-loc-for-EntityTeleportEvent.patch b/patches/server/Fix-NPE-on-null-loc-for-EntityTeleportEvent.patch similarity index 96% rename from patches/unapplied/server/Fix-NPE-on-null-loc-for-EntityTeleportEvent.patch rename to patches/server/Fix-NPE-on-null-loc-for-EntityTeleportEvent.patch index 8fcd3827b4..265ff403f6 100644 --- a/patches/unapplied/server/Fix-NPE-on-null-loc-for-EntityTeleportEvent.patch +++ b/patches/server/Fix-NPE-on-null-loc-for-EntityTeleportEvent.patch @@ -14,7 +14,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 --- a/src/main/java/net/minecraft/server/commands/TeleportCommand.java +++ b/src/main/java/net/minecraft/server/commands/TeleportCommand.java @@ -0,0 +0,0 @@ public class TeleportCommand { - Location to = new Location(world.getWorld(), x, y, z, f2, f3); + Location to = new Location(world.getWorld(), d3, d4, d5, f4, f5); EntityTeleportEvent event = new EntityTeleportEvent(target.getBukkitEntity(), target.getBukkitEntity().getLocation(), to); world.getCraftServer().getPluginManager().callEvent(event); - if (event.isCancelled()) { @@ -23,8 +23,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 } + to = event.getTo(); // Paper - actually track new location - x = to.getX(); - y = to.getY(); + d3 = to.getX(); + d4 = to.getY(); diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java diff --git a/patches/unapplied/server/Fix-UnsafeValues-loadAdvancement.patch b/patches/server/Fix-UnsafeValues-loadAdvancement.patch similarity index 96% rename from patches/unapplied/server/Fix-UnsafeValues-loadAdvancement.patch rename to patches/server/Fix-UnsafeValues-loadAdvancement.patch index 1c7d1517d6..d148784e60 100644 --- a/patches/unapplied/server/Fix-UnsafeValues-loadAdvancement.patch +++ b/patches/server/Fix-UnsafeValues-loadAdvancement.patch @@ -11,7 +11,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 @@ -0,0 +0,0 @@ public final class CraftMagicNumbers implements UnsafeValues { ResourceLocation minecraftkey = CraftNamespacedKey.toMinecraft(key); - JsonElement jsonelement = ServerAdvancementManager.GSON.fromJson(advancement, JsonElement.class); + JsonElement jsonelement = JsonParser.parseString(advancement); - net.minecraft.advancements.Advancement nms = net.minecraft.advancements.Advancement.CODEC.parse(JsonOps.INSTANCE, jsonelement).getOrThrow(JsonParseException::new); + final net.minecraft.resources.RegistryOps ops = CraftRegistry.getMinecraftRegistry().createSerializationContext(JsonOps.INSTANCE); // Paper - use RegistryOps + final net.minecraft.advancements.Advancement nms = net.minecraft.advancements.Advancement.CODEC.parse(ops, jsonelement).getOrThrow(JsonParseException::new); // Paper - use RegistryOps diff --git a/patches/unapplied/server/Fix-missing-event-call-for-entity-teleport-API.patch b/patches/server/Fix-missing-event-call-for-entity-teleport-API.patch similarity index 100% rename from patches/unapplied/server/Fix-missing-event-call-for-entity-teleport-API.patch rename to patches/server/Fix-missing-event-call-for-entity-teleport-API.patch diff --git a/patches/unapplied/server/Fix-missing-map-initialize-event-call.patch b/patches/server/Fix-missing-map-initialize-event-call.patch similarity index 98% rename from patches/unapplied/server/Fix-missing-map-initialize-event-call.patch rename to patches/server/Fix-missing-map-initialize-event-call.patch index a5686584c0..0f518827c5 100644 --- a/patches/unapplied/server/Fix-missing-map-initialize-event-call.patch +++ b/patches/server/Fix-missing-map-initialize-event-call.patch @@ -10,7 +10,7 @@ diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/mai index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java -@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe @Nullable @Override public MapItemSavedData getMapData(MapId id) { diff --git a/patches/server/Fix-new-block-data-for-EntityChangeBlockEvent.patch b/patches/server/Fix-new-block-data-for-EntityChangeBlockEvent.patch index a8570e365c..7b43845643 100644 --- a/patches/server/Fix-new-block-data-for-EntityChangeBlockEvent.patch +++ b/patches/server/Fix-new-block-data-for-EntityChangeBlockEvent.patch @@ -199,7 +199,7 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java +++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java -@@ -0,0 +0,0 @@ populateFields(victim, event); // Paper - make cancellable +@@ -0,0 +0,0 @@ public class CraftEventFactory { return event; } diff --git a/patches/unapplied/server/Fix-race-condition-on-UpgradeData.BlockFixers-class-.patch b/patches/server/Fix-race-condition-on-UpgradeData.BlockFixers-class-.patch similarity index 100% rename from patches/unapplied/server/Fix-race-condition-on-UpgradeData.BlockFixers-class-.patch rename to patches/server/Fix-race-condition-on-UpgradeData.BlockFixers-class-.patch diff --git a/patches/unapplied/server/Fix-several-issues-with-EntityBreedEvent.patch b/patches/server/Fix-several-issues-with-EntityBreedEvent.patch similarity index 85% rename from patches/unapplied/server/Fix-several-issues-with-EntityBreedEvent.patch rename to patches/server/Fix-several-issues-with-EntityBreedEvent.patch index 024d81250f..3d54a4b209 100644 --- a/patches/unapplied/server/Fix-several-issues-with-EntityBreedEvent.patch +++ b/patches/server/Fix-several-issues-with-EntityBreedEvent.patch @@ -22,9 +22,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 this.usePlayerItem(player, hand, itemstack); - this.setInLove(player); + this.setInLove(player, breedCopy); // Paper - Fix EntityBreedEvent copying - return InteractionResult.SUCCESS; + this.playEatingSound(); + return InteractionResult.SUCCESS_SERVER; } - @@ -0,0 +0,0 @@ public abstract class Animal extends AgeableMob { return this.inLove <= 0; } @@ -66,28 +66,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 - this.setInLove(player); + this.setInLove(player, breedCopy); // Paper - Fix EntityBreedEvent copying } else { - if (this.level().isClientSide || this.isSitting() || this.isInWater()) { - return InteractionResult.PASS; -diff --git a/src/main/java/net/minecraft/world/entity/animal/armadillo/Armadillo.java b/src/main/java/net/minecraft/world/entity/animal/armadillo/Armadillo.java -index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 ---- a/src/main/java/net/minecraft/world/entity/animal/armadillo/Armadillo.java -+++ b/src/main/java/net/minecraft/world/entity/animal/armadillo/Armadillo.java -@@ -0,0 +0,0 @@ public class Armadillo extends Animal { - } - - @Override -- public void setInLove(@Nullable Player player) { -- super.setInLove(player); -+ public void setInLove(@Nullable Player player, @Nullable ItemStack breedItemCopy) { // Paper -+ super.setInLove(player, breedItemCopy); // Paper - this.makeSound(SoundEvents.ARMADILLO_EAT); - } + Level world = this.level(); diff --git a/src/main/java/net/minecraft/world/entity/animal/camel/Camel.java b/src/main/java/net/minecraft/world/entity/animal/camel/Camel.java index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/net/minecraft/world/entity/animal/camel/Camel.java +++ b/src/main/java/net/minecraft/world/entity/animal/camel/Camel.java -@@ -0,0 +0,0 @@ public class Camel extends AbstractHorse implements PlayerRideableJumping, Saddl +@@ -0,0 +0,0 @@ public class Camel extends AbstractHorse { boolean flag1 = this.isTamed() && this.getAge() == 0 && this.canFallInLove(); if (flag1) { diff --git a/patches/unapplied/server/Fix-silent-equipment-change-for-mobs.patch b/patches/server/Fix-silent-equipment-change-for-mobs.patch similarity index 100% rename from patches/unapplied/server/Fix-silent-equipment-change-for-mobs.patch rename to patches/server/Fix-silent-equipment-change-for-mobs.patch diff --git a/patches/unapplied/server/Fix-slot-desync.patch b/patches/server/Fix-slot-desync.patch similarity index 96% rename from patches/unapplied/server/Fix-slot-desync.patch rename to patches/server/Fix-slot-desync.patch index 5b4bba36d0..658398ef26 100644 --- a/patches/unapplied/server/Fix-slot-desync.patch +++ b/patches/server/Fix-slot-desync.patch @@ -121,9 +121,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 +++ b/src/main/java/net/minecraft/world/item/MinecartItem.java @@ -0,0 +0,0 @@ public class MinecartItem extends Item { - // CraftBukkit start - if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityPlaceEvent(context, entityminecartabstract).isCancelled()) { + // CraftBukkit start + if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityPlaceEvent(context, entityminecartabstract).isCancelled()) { + if (context.getPlayer() != null) context.getPlayer().containerMenu.sendAllDataToRemote(); // Paper - Fix inventory desync - return InteractionResult.FAIL; - } - // CraftBukkit end + return InteractionResult.FAIL; + } + // CraftBukkit end diff --git a/patches/unapplied/server/Fix-spigot-s-Forced-Stats.patch b/patches/server/Fix-spigot-s-Forced-Stats.patch similarity index 100% rename from patches/unapplied/server/Fix-spigot-s-Forced-Stats.patch rename to patches/server/Fix-spigot-s-Forced-Stats.patch diff --git a/patches/unapplied/server/Fix-strikeLightningEffect-powers-lightning-rods-and-.patch b/patches/server/Fix-strikeLightningEffect-powers-lightning-rods-and-.patch similarity index 88% rename from patches/unapplied/server/Fix-strikeLightningEffect-powers-lightning-rods-and-.patch rename to patches/server/Fix-strikeLightningEffect-powers-lightning-rods-and-.patch index 59fdd66ffa..e35e7b3a79 100644 --- a/patches/unapplied/server/Fix-strikeLightningEffect-powers-lightning-rods-and-.patch +++ b/patches/server/Fix-strikeLightningEffect-powers-lightning-rods-and-.patch @@ -39,18 +39,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 } private void spawnFire(int spreadAttempts) { -- if (!this.visualOnly && !this.level().isClientSide && this.level().getGameRules().getBoolean(GameRules.RULE_DOFIRETICK)) { -+ if (!this.visualOnly && !this.isEffect && !this.level().isClientSide && this.level().getGameRules().getBoolean(GameRules.RULE_DOFIRETICK)) { // Paper - Properly handle lightning effects api - BlockPos blockposition = this.blockPosition(); - BlockState iblockdata = BaseFireBlock.getState(this.level(), blockposition); +- if (!this.visualOnly) { ++ if (!this.visualOnly && !this.isEffect) { // Paper - Properly handle lightning effects api + Level world = this.level(); + if (world instanceof ServerLevel) { diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java @@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World { - LightningBolt lightning = EntityType.LIGHTNING_BOLT.create(this.world); + LightningBolt lightning = EntityType.LIGHTNING_BOLT.create(this.world, EntitySpawnReason.COMMAND); lightning.moveTo(loc.getX(), loc.getY(), loc.getZ()); - lightning.setVisualOnly(isVisual); + lightning.isEffect = isVisual; // Paper - Properly handle lightning effects api diff --git a/patches/unapplied/server/Fix-team-sidebar-objectives-not-being-cleared.patch b/patches/server/Fix-team-sidebar-objectives-not-being-cleared.patch similarity index 100% rename from patches/unapplied/server/Fix-team-sidebar-objectives-not-being-cleared.patch rename to patches/server/Fix-team-sidebar-objectives-not-being-cleared.patch diff --git a/patches/unapplied/server/Implement-OfflinePlayer-isConnected.patch b/patches/server/Implement-OfflinePlayer-isConnected.patch similarity index 100% rename from patches/unapplied/server/Implement-OfflinePlayer-isConnected.patch rename to patches/server/Implement-OfflinePlayer-isConnected.patch diff --git a/patches/unapplied/server/Improve-Registry.patch b/patches/server/Improve-Registry.patch similarity index 100% rename from patches/unapplied/server/Improve-Registry.patch rename to patches/server/Improve-Registry.patch diff --git a/patches/server/Improve-death-events.patch b/patches/server/Improve-death-events.patch index 1a78fc7a3e..57a4612990 100644 --- a/patches/server/Improve-death-events.patch +++ b/patches/server/Improve-death-events.patch @@ -463,7 +463,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 PlayerDeathEvent event = new PlayerDeathEvent(entity, bukkitDamageSource, drops, victim.getExpReward(victim.serverLevel(), damageSource.getEntity()), 0, deathMessage); event.setKeepInventory(keepInventory); event.setKeepLevel(victim.keepLevel); // SPIGOT-2222: pre-set keepLevel -+populateFields(victim, event); // Paper - make cancellable ++ populateFields(victim, event); // Paper - make cancellable Bukkit.getServer().getPluginManager().callEvent(event); + // Paper start - make cancellable + if (event.isCancelled()) { diff --git a/patches/unapplied/server/Lazily-create-LootContext-for-criterions.patch b/patches/server/Lazily-create-LootContext-for-criterions.patch similarity index 100% rename from patches/unapplied/server/Lazily-create-LootContext-for-criterions.patch rename to patches/server/Lazily-create-LootContext-for-criterions.patch diff --git a/patches/unapplied/server/More-DragonBattle-API.patch b/patches/server/More-DragonBattle-API.patch similarity index 100% rename from patches/unapplied/server/More-DragonBattle-API.patch rename to patches/server/More-DragonBattle-API.patch diff --git a/patches/unapplied/server/Optimize-VarInts.patch b/patches/server/Optimize-VarInts.patch similarity index 100% rename from patches/unapplied/server/Optimize-VarInts.patch rename to patches/server/Optimize-VarInts.patch diff --git a/patches/unapplied/server/Optimize-nearest-structure-border-iteration.patch b/patches/server/Optimize-nearest-structure-border-iteration.patch similarity index 100% rename from patches/unapplied/server/Optimize-nearest-structure-border-iteration.patch rename to patches/server/Optimize-nearest-structure-border-iteration.patch diff --git a/patches/unapplied/server/Restore-vanilla-entity-drops-behavior.patch b/patches/server/Restore-vanilla-entity-drops-behavior.patch similarity index 89% rename from patches/unapplied/server/Restore-vanilla-entity-drops-behavior.patch rename to patches/server/Restore-vanilla-entity-drops-behavior.patch index 396e565ee1..94e3f2e739 100644 --- a/patches/unapplied/server/Restore-vanilla-entity-drops-behavior.patch +++ b/patches/server/Restore-vanilla-entity-drops-behavior.patch @@ -18,7 +18,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 } - java.util.List loot = new java.util.ArrayList<>(this.getInventory().getContainerSize()); + List loot = new java.util.ArrayList<>(this.getInventory().getContainerSize()); // Paper - Restore vanilla drops behavior - boolean keepInventory = this.level().getGameRules().getBoolean(GameRules.RULE_KEEPINVENTORY) || this.isSpectator(); + boolean keepInventory = this.serverLevel().getGameRules().getBoolean(GameRules.RULE_KEEPINVENTORY) || this.isSpectator(); if (!keepInventory) { for (ItemStack item : this.getInventory().getContents()) { @@ -30,7 +30,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 } if (this.shouldDropLoot() && this.level().getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) { // Paper - fix player loottables running when mob loot gamerule is false // SPIGOT-5071: manually add player loot tables (SPIGOT-5195 - ignores keepInventory rule) - this.dropFromLootTable(damageSource, this.lastHurtByPlayerTime > 0); + this.dropFromLootTable(this.serverLevel(), damageSource, this.lastHurtByPlayerTime > 0); - this.dropCustomDeathLoot(this.serverLevel(), damageSource, flag); + // Paper - Restore vanilla drops behaviour; custom death loot is a noop on server player, remove. @@ -43,9 +43,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 @@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess @Nullable - public ItemEntity spawnAtLocation(ItemStack stack, float yOffset) { + public ItemEntity spawnAtLocation(ServerLevel world, ItemStack stack, float yOffset) { + // Paper start - Restore vanilla drops behavior -+ return this.spawnAtLocation(stack, yOffset, null); ++ return this.spawnAtLocation(world, stack, yOffset, null); + } + public record DefaultDrop(Item item, org.bukkit.inventory.ItemStack stack, @Nullable java.util.function.Consumer dropConsumer) { + public DefaultDrop(final ItemStack stack, final java.util.function.Consumer dropConsumer) { @@ -61,12 +61,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + } + } + @Nullable -+ public ItemEntity spawnAtLocation(ItemStack stack, float yOffset, @Nullable java.util.function.Consumer delayedAddConsumer) { ++ public ItemEntity spawnAtLocation(ServerLevel world, ItemStack stack, float yOffset, @Nullable java.util.function.Consumer delayedAddConsumer) { + // Paper end - Restore vanilla drops behavior if (stack.isEmpty()) { return null; - } else if (this.level().isClientSide) { -@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess } else { // CraftBukkit start - Capture drops for death event if (this instanceof net.minecraft.world.entity.LivingEntity && !((net.minecraft.world.entity.LivingEntity) this).forceDrops) { @@ -82,7 +80,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 return null; } // CraftBukkit end - ItemEntity entityitem = new ItemEntity(this.level(), this.getX(), this.getY() + (double) yOffset, this.getZ(), stack.copy()); // Paper - copy so we can destroy original + ItemEntity entityitem = new ItemEntity(world, this.getX(), this.getY() + (double) yOffset, this.getZ(), stack); stack.setCount(0); // Paper - destroy this item - if this ever leaks due to game bugs, ensure it doesn't dupe - entityitem.setDefaultPickUpDelay(); @@ -107,13 +105,13 @@ diff --git a/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.jav index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java +++ b/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java -@@ -0,0 +0,0 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -0,0 +0,0 @@ public class WitherBoss extends Monster implements RangedAttackMob { @Override protected void dropCustomDeathLoot(ServerLevel world, DamageSource source, boolean causedByPlayer) { super.dropCustomDeathLoot(world, source, causedByPlayer); -- ItemEntity entityitem = this.spawnAtLocation((ItemLike) Items.NETHER_STAR); -- -+ ItemEntity entityitem = this.spawnAtLocation(new net.minecraft.world.item.ItemStack(Items.NETHER_STAR), 0, ItemEntity::setExtendedLifetime); // Paper - Restore vanilla drops behavior; spawnAtLocation returns null so modify the item entity with a consumer +- ItemEntity entityitem = this.spawnAtLocation(world, (ItemLike) Items.NETHER_STAR); ++ ItemEntity entityitem = this.spawnAtLocation(world, new net.minecraft.world.item.ItemStack(Items.NETHER_STAR), 0, ItemEntity::setExtendedLifetime); // Paper - Restore vanilla drops behavior; spawnAtLocation returns null so modify the item entity with a consumer + if (entityitem != null) { - entityitem.setExtendedLifetime(); + entityitem.setExtendedLifetime(); // Paper - diff on change @@ -175,15 +173,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + return new Entity.DefaultDrop(CraftItemType.bukkitToMinecraft(stack.getType()), stack, null); + }; + -+ public static EntityDeathEvent callEntityDeathEvent(net.minecraft.world.entity.LivingEntity victim, DamageSource damageSource, List drops, Runnable lootCheck) { // Paper ++ public static EntityDeathEvent callEntityDeathEvent(net.minecraft.world.entity.LivingEntity victim, DamageSource damageSource, List drops, Runnable lootCheck) { // Paper - Restore vanilla drops behavior // Paper end CraftLivingEntity entity = (CraftLivingEntity) victim.getBukkitEntity(); CraftDamageSource bukkitDamageSource = new CraftDamageSource(damageSource); -- EntityDeathEvent event = new EntityDeathEvent(entity, bukkitDamageSource, drops, victim.getExpReward(damageSource.getEntity())); -+ EntityDeathEvent event = new EntityDeathEvent(entity, bukkitDamageSource, new io.papermc.paper.util.TransformingRandomAccessList<>(drops, Entity.DefaultDrop::stack, FROM_FUNCTION), victim.getExpReward(damageSource.getEntity())); // Paper - Restore vanilla drops behavior - populateFields(victim, event); // Paper - make cancellable CraftWorld world = (CraftWorld) entity.getWorld(); +- EntityDeathEvent event = new EntityDeathEvent(entity, bukkitDamageSource, drops, victim.getExpReward(world.getHandle(), damageSource.getEntity())); ++ EntityDeathEvent event = new EntityDeathEvent(entity, bukkitDamageSource, new io.papermc.paper.util.TransformingRandomAccessList<>(drops, Entity.DefaultDrop::stack, FROM_FUNCTION), victim.getExpReward(world.getHandle(), damageSource.getEntity())); // Paper - Restore vanilla drops behavior, victim.getExpReward(world.getHandle(), damageSource.getEntity())); + populateFields(victim, event); // Paper - make cancellable Bukkit.getServer().getPluginManager().callEvent(event); + @@ -0,0 +0,0 @@ public class CraftEventFactory { victim.expToDrop = event.getDroppedExp(); lootCheck.run(); // Paper - advancement triggers before destroying items @@ -193,7 +192,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + for (Entity.DefaultDrop drop : drops) { + if (drop == null) continue; + final org.bukkit.inventory.ItemStack stack = drop.stack(); -+ // Paper end - Restore vanilla drops behavior ++ // Paper end - Restore vanilla drops behavior if (stack == null || stack.getType() == Material.AIR || stack.getAmount() == 0) continue; - world.dropItem(entity.getLocation(), stack); // Paper - note: dropItem already clones due to this being bukkit -> NMS @@ -208,8 +207,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + public static PlayerDeathEvent callPlayerDeathEvent(ServerPlayer victim, DamageSource damageSource, List drops, net.kyori.adventure.text.Component deathMessage, boolean keepInventory) { // Paper - Adventure & Restore vanilla drops behavior CraftPlayer entity = victim.getBukkitEntity(); CraftDamageSource bukkitDamageSource = new CraftDamageSource(damageSource); -- PlayerDeathEvent event = new PlayerDeathEvent(entity, bukkitDamageSource, drops, victim.getExpReward(damageSource.getEntity()), 0, deathMessage); -+ PlayerDeathEvent event = new PlayerDeathEvent(entity, bukkitDamageSource, new io.papermc.paper.util.TransformingRandomAccessList<>(drops, Entity.DefaultDrop::stack, FROM_FUNCTION), victim.getExpReward(damageSource.getEntity()), 0, deathMessage); // Paper - Restore vanilla drops behavior +- PlayerDeathEvent event = new PlayerDeathEvent(entity, bukkitDamageSource, drops, victim.getExpReward(victim.serverLevel(), damageSource.getEntity()), 0, deathMessage); ++ PlayerDeathEvent event = new PlayerDeathEvent(entity, bukkitDamageSource, new io.papermc.paper.util.TransformingRandomAccessList<>(drops, Entity.DefaultDrop::stack, FROM_FUNCTION), victim.getExpReward(victim.serverLevel(), damageSource.getEntity()), 0, deathMessage); // Paper - Restore vanilla drops behavior event.setKeepInventory(keepInventory); event.setKeepLevel(victim.keepLevel); // SPIGOT-2222: pre-set keepLevel populateFields(victim, event); // Paper - make cancellable @@ -222,14 +221,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + for (Entity.DefaultDrop drop : drops) { + if (drop == null) continue; + final org.bukkit.inventory.ItemStack stack = drop.stack(); -+ // Paper end - Restore vanilla drops behavior ++ // Paper end - Restore vanilla drops behavior if (stack == null || stack.getType() == Material.AIR) continue; - if (stack instanceof CraftItemStack craftItemStack && craftItemStack.isForInventoryDrop()) { - victim.drop(CraftItemStack.asNMSCopy(stack), true, false, false); // SPIGOT-7800, SPIGOT-7801: Vanilla Behaviour for Player Inventory dropped items - } else { - victim.forceDrops = true; -- victim.spawnAtLocation(CraftItemStack.asNMSCopy(stack)); // SPIGOT-7806: Vanilla Behaviour for items not related to Player Inventory dropped items +- victim.spawnAtLocation(victim.serverLevel(), CraftItemStack.asNMSCopy(stack)); // SPIGOT-7806: Vanilla Behaviour for items not related to Player Inventory dropped items - victim.forceDrops = false; - } + drop.runConsumer(s -> victim.drop(CraftItemStack.unwrap(s), true, false, false)); // Paper - Restore vanilla drops behavior diff --git a/patches/unapplied/server/Skip-POI-finding-if-stuck-in-vehicle.patch b/patches/server/Skip-POI-finding-if-stuck-in-vehicle.patch similarity index 100% rename from patches/unapplied/server/Skip-POI-finding-if-stuck-in-vehicle.patch rename to patches/server/Skip-POI-finding-if-stuck-in-vehicle.patch diff --git a/patches/unapplied/server/Update-entity-data-when-attaching-firework-to-entity.patch b/patches/server/Update-entity-data-when-attaching-firework-to-entity.patch similarity index 100% rename from patches/unapplied/server/Update-entity-data-when-attaching-firework-to-entity.patch rename to patches/server/Update-entity-data-when-attaching-firework-to-entity.patch diff --git a/patches/unapplied/server/add-more-scoreboard-API.patch b/patches/server/add-more-scoreboard-API.patch similarity index 100% rename from patches/unapplied/server/add-more-scoreboard-API.patch rename to patches/server/add-more-scoreboard-API.patch