From efb91589dc7649cd20f8f0b7d499c32f38f768f2 Mon Sep 17 00:00:00 2001 From: Nassim Jahnke Date: Sat, 15 Jun 2024 18:28:18 +0200 Subject: [PATCH] Updated Upstream (Bukkit/CraftBukkit) Upstream has released updates that appear to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: e2160a18 Make MapCursor#type not depends on deprecated values CraftBukkit Changes: 6ce172642 SPIGOT-7761: Ender pearl does not damage or spawn endermites f5a63f734 SPIGOT-7759: Chunk not there when requested in ChunkUnloadEvent 28287259c Remove unused import eb9a7dde0 SPIGOT-7757: Cannot set item in Stonecutter Inventory f8be9d752 Move deserialized removed unhandled tags to dedicated removedTags a7e576186 Fix potential mutability issue with CraftMetaItem copy constructor 995885452 SPIGOT-7741: Vanilla ItemComponent in commands can't remove components 9ef69aa0b PR-1284: Move ItemType <-> ItemMeta linking to a centralized place 3e82eafbe PR-1420: Fix DirectEntity and CausingEntity Damager for Creepers ignited by Player c23daa71f SPIGOT-7751: Fix crash caused by arrows from trial spawners Make MapCursor#type not depends on deprecated values SPIGOT-7761: Ender pearl does not damage or spawn endermites --- patches/api/Adventure.patch | 34 +- ...Allow-to-define-new-map-cursor-types.patch | 30 -- .../api/Fix-Spigot-annotation-mistakes.patch | 6 +- patches/server/Add-ArmorStand-Item-Meta.patch | 31 +- ...gistryAccess-for-managing-Registries.patch | 4 +- patches/server/Adventure.patch | 2 +- ...Chunk-System-Starlight-from-Moonrise.patch | 17 +- .../server/Deep-clone-nbt-tags-in-PDC.patch | 6 +- ...-removed-data-components-in-ItemMeta.patch | 8 +- patches/server/Fix-DamageSource-API.patch | 33 +- patches/server/Fix-ItemFlags.patch | 25 +- patches/server/General-ItemMeta-fixes.patch | 19 +- patches/server/MC-Utils.patch | 2 +- patches/server/More-Projectile-API.patch | 21 +- patches/server/More-Teleport-API.patch | 2 +- patches/server/Test-changes.patch | 2 +- .../fix-item-meta-for-tadpole-buckets.patch | 35 +- ...ve-checking-handled-tags-in-itemmeta.patch | 308 ++++++++++-------- work/Bukkit | 2 +- work/CraftBukkit | 2 +- 20 files changed, 311 insertions(+), 278 deletions(-) delete mode 100644 patches/api/Allow-to-define-new-map-cursor-types.patch diff --git a/patches/api/Adventure.patch b/patches/api/Adventure.patch index 95b0116ced..c089e1072e 100644 --- a/patches/api/Adventure.patch +++ b/patches/api/Adventure.patch @@ -4809,13 +4809,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 +++ b/src/main/java/org/bukkit/map/MapCursor.java @@ -0,0 +0,0 @@ public final class MapCursor { private byte x, y; - private byte direction, type; + private byte direction; private boolean visible; - private String caption; + private net.kyori.adventure.text.Component caption; // Paper + private Type type; /** - * Initialize the map cursor. @@ -0,0 +0,0 @@ public final class MapCursor { */ @Deprecated @@ -4838,8 +4838,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 * @param type The type (color/style) of the map cursor. * @param visible Whether the cursor is visible by default. * @param caption cursor caption -- * @deprecated Magic value -+ * @deprecated Magic value. Use {@link #MapCursor(byte, byte, byte, byte, boolean, net.kyori.adventure.text.Component)} +- * @deprecated Magic value, use {@link #MapCursor(byte, byte, byte, Type, boolean, String)} ++ * @deprecated Magic value. Use {@link #MapCursor(byte, byte, byte, Type, boolean, net.kyori.adventure.text.Component)} */ @Deprecated public MapCursor(byte x, byte y, byte direction, byte type, boolean visible, @Nullable String caption) { @@ -4849,7 +4849,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 this.visible = visible; - this.caption = caption; + this.caption = caption == null ? null : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(caption); // Paper - } ++ } + // Paper start + /** + * Initialize the map cursor. @@ -4867,7 +4867,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + this.x = x; this.y = y; this.visible = visible; this.caption = caption; + setDirection(direction); + setRawType(type); -+ } + } + /** + * Initialize the map cursor. + * @@ -4889,7 +4889,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 * Initialize the map cursor. @@ -0,0 +0,0 @@ public final class MapCursor { setDirection(direction); - setType(type); + this.type = type; this.visible = visible; - this.caption = caption; + this.caption = caption == null ? null : net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(caption); // Paper @@ -4901,11 +4901,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 } + // Paper start -+ /** -+ * Gets the caption on this cursor. -+ * -+ * @return caption -+ */ + /** + * Gets the caption on this cursor. + * + * @return caption + */ + public net.kyori.adventure.text.@Nullable Component caption() { + return this.caption; + } @@ -4918,12 +4918,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + this.caption = caption; + } + // Paper end - /** - * Gets the caption on this cursor. - * - * @return caption ++ /** ++ * Gets the caption on this cursor. ++ * ++ * @return caption + * @deprecated in favour of {@link #caption()} - */ ++ */ @Nullable + @Deprecated // Paper public String getCaption() { diff --git a/patches/api/Allow-to-define-new-map-cursor-types.patch b/patches/api/Allow-to-define-new-map-cursor-types.patch deleted file mode 100644 index 31286c39f1..0000000000 --- a/patches/api/Allow-to-define-new-map-cursor-types.patch +++ /dev/null @@ -1,30 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com> -Date: Fri, 24 May 2024 20:19:07 +0200 -Subject: [PATCH] Allow to define new map cursor types - - -diff --git a/src/main/java/org/bukkit/map/MapCursor.java b/src/main/java/org/bukkit/map/MapCursor.java -index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 ---- a/src/main/java/org/bukkit/map/MapCursor.java -+++ b/src/main/java/org/bukkit/map/MapCursor.java -@@ -0,0 +0,0 @@ public final class MapCursor { - */ - @Deprecated(forRemoval = true, since = "1.20.2") // Paper - public void setRawType(byte type) { -- if (type < 0 || type > 34) { -- throw new IllegalArgumentException("Type must be in the range 0-34"); -+ if (type < 0 || type > Type.UPPER_MAP_CURSOR_TYPE_BOUND) { // Paper -+ throw new IllegalArgumentException("Type must be in the range 0-" + Type.UPPER_MAP_CURSOR_TYPE_BOUND); // Paper - } - this.type = type; - } -@@ -0,0 +0,0 @@ public final class MapCursor { - TRIAL_CHAMBERS(34, "trial_chambers") - ; - -+ static final int UPPER_MAP_CURSOR_TYPE_BOUND = Type.values().length - 1; // Paper - cached max value of Type -+ - private byte value; - private final NamespacedKey key; - diff --git a/patches/api/Fix-Spigot-annotation-mistakes.patch b/patches/api/Fix-Spigot-annotation-mistakes.patch index b82cc3cf1d..babf660a57 100644 --- a/patches/api/Fix-Spigot-annotation-mistakes.patch +++ b/patches/api/Fix-Spigot-annotation-mistakes.patch @@ -1690,7 +1690,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 - @Deprecated + @org.jetbrains.annotations.ApiStatus.Internal // Paper public byte getRawType() { - return type; + return type.value; } @@ -0,0 +0,0 @@ public final class MapCursor { * Set the type of this cursor. @@ -1702,8 +1702,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 - @Deprecated + @Deprecated(forRemoval = true, since = "1.20.2") // Paper public void setRawType(byte type) { - if (type < 0 || type > 34) { - throw new IllegalArgumentException("Type must be in the range 0-34"); + Type enumType = Type.byValue(type); + Preconditions.checkArgument(enumType != null, "Unknown type by id %s", type); @@ -0,0 +0,0 @@ public final class MapCursor { * Gets the internal value of the cursor. * diff --git a/patches/server/Add-ArmorStand-Item-Meta.patch b/patches/server/Add-ArmorStand-Item-Meta.patch index 6591aacacc..036981fe94 100644 --- a/patches/server/Add-ArmorStand-Item-Meta.patch +++ b/patches/server/Add-ArmorStand-Item-Meta.patch @@ -12,19 +12,26 @@ starting point for future additions in this area. Fixes GH-559 -diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemType.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemType.java +diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 ---- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemType.java -+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemType.java -@@ -0,0 +0,0 @@ public class CraftItemType implements ItemType.Typed, Han - private Class getItemMetaClass(Item item) { - ItemMeta meta = new ItemStack(this.asMaterial()).getItemMeta(); - if (meta != null) { -- if (CraftMetaEntityTag.class != meta.getClass() && CraftMetaArmorStand.class != meta.getClass()) { -+ if (CraftMetaEntityTag.class != meta.getClass()/* && CraftMetaArmorStand.class != meta.getClass()*/) { // Paper - CraftMetaArmorStand is implemented in the API via ArmorStandMeta. - return (Class) meta.getClass().getInterfaces()[0]; - } - } +--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java ++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java +@@ -0,0 +0,0 @@ + package org.bukkit.craftbukkit.inventory; + ++import com.destroystokyo.paper.inventory.meta.ArmorStandMeta; + import java.util.function.BiFunction; + import java.util.function.Function; + import net.minecraft.world.item.ItemStack; +@@ -0,0 +0,0 @@ public final class CraftItemMetas { + item -> new CraftMetaSpawnEgg(item.getComponentsPatch()), + (type, meta) -> meta instanceof CraftMetaSpawnEgg spawnEgg ? spawnEgg : new CraftMetaSpawnEgg(meta)); + +- private static final ItemMetaData ARMOR_STAND_META_DATA = new ItemMetaData<>(ItemMeta.class, ++ private static final ItemMetaData ARMOR_STAND_META_DATA = new ItemMetaData<>(ArmorStandMeta.class, // paper + item -> new CraftMetaArmorStand(item.getComponentsPatch()), + (type, meta) -> meta instanceof CraftMetaArmorStand armorStand ? armorStand : new CraftMetaArmorStand(meta)); + diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaArmorStand.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaArmorStand.java index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaArmorStand.java diff --git a/patches/server/Add-RegistryAccess-for-managing-Registries.patch b/patches/server/Add-RegistryAccess-for-managing-Registries.patch index 4651447b7c..4792b357d4 100644 --- a/patches/server/Add-RegistryAccess-for-managing-Registries.patch +++ b/patches/server/Add-RegistryAccess-for-managing-Registries.patch @@ -1070,8 +1070,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 - }); + // Paper - RegistryAccess - // Paper start - testing additions - final Thread currentThread = Thread.currentThread(); + when(instance.getTag(any(), any(), any())).then(mock -> { + String registry = mock.getArgument(0); diff --git a/src/test/java/org/bukkit/support/provider/RegistriesArgumentProvider.java b/src/test/java/org/bukkit/support/provider/RegistriesArgumentProvider.java index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/test/java/org/bukkit/support/provider/RegistriesArgumentProvider.java diff --git a/patches/server/Adventure.patch b/patches/server/Adventure.patch index e6178e88e8..7deaa58eae 100644 --- a/patches/server/Adventure.patch +++ b/patches/server/Adventure.patch @@ -5121,7 +5121,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 --- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java +++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java @@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta { - return !(this.hasDisplayName() || this.hasItemName() || this.hasLocalizedName() || this.hasEnchants() || (this.lore != null) || this.hasCustomModelData() || this.hasBlockData() || this.hasRepairCost() || !this.unhandledTags.build().isEmpty() || !this.persistentDataContainer.isEmpty() || this.hideFlag != 0 || this.isHideTooltip() || this.isUnbreakable() || this.hasEnchantmentGlintOverride() || this.isFireResistant() || this.hasMaxStackSize() || this.hasRarity() || this.hasFood() || this.hasTool() || this.hasDamage() || this.hasMaxDamage() || this.hasAttributeModifiers() || this.customTag != null); + return !(this.hasDisplayName() || this.hasItemName() || this.hasLocalizedName() || this.hasEnchants() || (this.lore != null) || this.hasCustomModelData() || this.hasBlockData() || this.hasRepairCost() || !this.unhandledTags.build().isEmpty() || !this.removedTags.isEmpty() || !this.persistentDataContainer.isEmpty() || this.hideFlag != 0 || this.isHideTooltip() || this.isUnbreakable() || this.hasEnchantmentGlintOverride() || this.isFireResistant() || this.hasMaxStackSize() || this.hasRarity() || this.hasFood() || this.hasTool() || this.hasDamage() || this.hasMaxDamage() || this.hasAttributeModifiers() || this.customTag != null); } + // Paper start diff --git a/patches/server/Chunk-System-Starlight-from-Moonrise.patch b/patches/server/Chunk-System-Starlight-from-Moonrise.patch index d9e0205a7c..fe55b64ead 100644 --- a/patches/server/Chunk-System-Starlight-from-Moonrise.patch +++ b/patches/server/Chunk-System-Starlight-from-Moonrise.patch @@ -11605,7 +11605,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + } + + // ticket level state -+ private int oldTicketLevel = ChunkHolderManager.MAX_TICKET_LEVEL + 1; ++ public int oldTicketLevel = ChunkHolderManager.MAX_TICKET_LEVEL + 1; + private int currentTicketLevel = ChunkHolderManager.MAX_TICKET_LEVEL + 1; + + public int getTicketLevel() { @@ -22635,6 +22635,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 } // Paper end // CraftBukkit start + public LevelChunk getFullChunkNow() { + // Note: We use the oldTicketLevel for isLoaded checks. +- if (!ChunkLevel.fullStatus(this.oldTicketLevel).isOrAfter(FullChunkStatus.FULL)) return null; ++ if (!ChunkLevel.fullStatus(this.newChunkHolder.oldTicketLevel).isOrAfter(FullChunkStatus.FULL)) return null; // Paper - rewrite chunk system + return this.getFullChunkNowUnchecked(); + } + @@ -0,0 +0,0 @@ public class ChunkHolder extends GenerationChunkHolder { // CraftBukkit end @@ -24862,12 +24869,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + }; - return this.chunkAbsent(playerchunk, l) ? GenerationChunkHolder.UNLOADED_CHUNK_FUTURE : playerchunk.scheduleChunkGenerationTask(leastStatus, this.chunkMap); +- } + ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)this.level).moonrise$getChunkTaskScheduler().scheduleChunkLoad( + chunkX, chunkZ, leastStatus, true, + ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor.Priority.HIGHER, + complete + ); -+ + +- private boolean chunkAbsent(@Nullable ChunkHolder holder, int maxLevel) { +- return holder == null || holder.oldTicketLevel > maxLevel; // CraftBukkit using oldTicketLevel for isLoaded checks + return ret; + } else { + // can return now @@ -24876,9 +24886,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + // Paper end - rewrite chunk system } - private boolean chunkAbsent(@Nullable ChunkHolder holder, int maxLevel) { -@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource { - @Override public boolean hasChunk(int x, int z) { - ChunkHolder playerchunk = this.getVisibleChunkIfPresent((new ChunkPos(x, z)).toLong()); diff --git a/patches/server/Deep-clone-nbt-tags-in-PDC.patch b/patches/server/Deep-clone-nbt-tags-in-PDC.patch index 1274032c49..65d2bf0711 100644 --- a/patches/server/Deep-clone-nbt-tags-in-PDC.patch +++ b/patches/server/Deep-clone-nbt-tags-in-PDC.patch @@ -9,18 +9,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 --- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java +++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java @@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta { - this.damage = meta.damage; this.maxDamage = meta.maxDamage; - this.unhandledTags = meta.unhandledTags; + this.unhandledTags.copy(meta.unhandledTags.build()); + this.removedTags.addAll(meta.removedTags); - this.persistentDataContainer.putAll(meta.persistentDataContainer.getRaw()); + this.persistentDataContainer.putAll(meta.persistentDataContainer.getTagsCloned()); // Paper - deep clone NBT tags this.customTag = meta.customTag; @@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta { - if (this.customTag != null) { clone.customTag = this.customTag.copy(); } + clone.removedTags = Sets.newHashSet(this.removedTags); - clone.persistentDataContainer = new CraftPersistentDataContainer(this.persistentDataContainer.getRaw(), CraftMetaItem.DATA_TYPE_REGISTRY); + clone.persistentDataContainer = new CraftPersistentDataContainer(this.persistentDataContainer.getTagsCloned(), CraftMetaItem.DATA_TYPE_REGISTRY); // Paper - deep clone NBT tags clone.hideFlag = this.hideFlag; diff --git a/patches/server/Don-t-lose-removed-data-components-in-ItemMeta.patch b/patches/server/Don-t-lose-removed-data-components-in-ItemMeta.patch index fdf1bf25ec..cbf156a045 100644 --- a/patches/server/Don-t-lose-removed-data-components-in-ItemMeta.patch +++ b/patches/server/Don-t-lose-removed-data-components-in-ItemMeta.patch @@ -27,12 +27,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 Set, Optional>> keys = tag.entrySet(); for (Map.Entry, Optional> key : keys) { - if (!CraftMetaItem.getHandledTags().contains(key.getKey())) { ++ // Paper start - don't lose unhandled tags + if (key.getValue().isEmpty()) { + this.unhandledTags.remove(key.getKey()); + } else if (!CraftMetaItem.getHandledTags().contains(key.getKey())) { - key.getValue().ifPresentOrElse((value) -> { ++ // Paper end - don't lose unhandled tags + key.getValue().ifPresent((value) -> { this.unhandledTags.set((DataComponentType) key.getKey(), value); - }, () -> { + }); @@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta { } @@ -44,4 +46,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + }, () -> itemTag.remove(e.getKey())); } - CompoundTag customTag = (this.customTag != null) ? this.customTag.copy() : null; + for (DataComponentType removed : this.removedTags) { diff --git a/patches/server/Fix-DamageSource-API.patch b/patches/server/Fix-DamageSource-API.patch index 9858ad6efd..230b3a1ca1 100644 --- a/patches/server/Fix-DamageSource-API.patch +++ b/patches/server/Fix-DamageSource-API.patch @@ -14,7 +14,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 private boolean sweep = false; private boolean melting = false; private boolean poison = false; -- private Entity customEntityDamager = null; // This field is a helper for when causing entity damage is not set by vanilla +- private Entity customEntityDamager = null; // This field is a helper for when direct entity damage is not set by vanilla +- private Entity customCausingEntityDamager = null; // This field is a helper for when causing entity damage is not set by vanilla + @Nullable + private Entity customEventDamager = null; // This field is a helper for when causing entity damage is not set by vanilla // Paper - fix DamageSource API @@ -26,23 +27,38 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 - public Entity getDamager() { - return (this.customEntityDamager != null) ? this.customEntityDamager : this.directEntity; +- } +- +- public Entity getCausingDamager() { +- return (this.customCausingEntityDamager != null) ? this.customCausingEntityDamager : this.causingEntity; +- } +- +- public DamageSource customEntityDamager(Entity entity) { +- // This method is not intended for change the causing entity if is already set +- // also is only necessary if the entity passed is not the direct entity or different from the current causingEntity +- if (this.customEntityDamager != null || this.directEntity == entity || this.causingEntity == entity) { +- return this; +- } +- DamageSource damageSource = this.cloneInstance(); +- damageSource.customEntityDamager = entity; +- return damageSource; + // Paper start - fix DamageSource API + @Nullable + public Entity getCustomEventDamager() { + return (this.customEventDamager != null) ? this.customEventDamager : this.directEntity; } -- public DamageSource customEntityDamager(Entity entity) { +- public DamageSource customCausingEntityDamager(Entity entity) { - // This method is not intended for change the causing entity if is already set - // also is only necessary if the entity passed is not the direct entity or different from the current causingEntity -- if (this.customEntityDamager != null || this.directEntity == entity || this.causingEntity == entity) { +- if (this.customCausingEntityDamager != null || this.directEntity == entity || this.causingEntity == entity) { - return this; + public DamageSource customEventDamager(Entity entity) { + if (this.directEntity != null) { + throw new IllegalStateException("Cannot set custom event damager when direct entity is already set (report a bug to Paper)"); } DamageSource damageSource = this.cloneInstance(); -- damageSource.customEntityDamager = entity; +- damageSource.customCausingEntityDamager = entity; + damageSource.customEventDamager = entity; + // Paper end - fix DamageSource API return damageSource; @@ -114,7 +130,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 if (!event.isCancelled()) { // CraftBukkit end this.dead = true; -- this.level().explode(this, net.minecraft.world.level.Explosion.getDefaultDamageSource(this.level(), this).customEntityDamager(this.entityIgniter), null, this.getX(), this.getY(), this.getZ(), event.getRadius(), event.getFire(), Level.ExplosionInteraction.MOB); // CraftBukkit +- this.level().explode(this, net.minecraft.world.level.Explosion.getDefaultDamageSource(this.level(), this).customCausingEntityDamager(this.entityIgniter), null, this.getX(), this.getY(), this.getZ(), event.getRadius(), event.getFire(), Level.ExplosionInteraction.MOB); // CraftBukkit + this.level().explode(this, this.getX(), this.getY(), this.getZ(), event.getRadius(), event.getFire(), Level.ExplosionInteraction.MOB); // CraftBukkit // Paper - fix DamageSource API (revert to vanilla, no, just no, don't change this) this.spawnLingeringCloud(); this.triggerOnDeathMobEffects(Entity.RemovalReason.KILLED); @@ -164,6 +180,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 +++ b/src/main/java/org/bukkit/craftbukkit/damage/CraftDamageSource.java @@ -0,0 +0,0 @@ public class CraftDamageSource implements DamageSource { + @Override + public org.bukkit.entity.Entity getCausingEntity() { +- net.minecraft.world.entity.Entity entity = this.getHandle().getCausingDamager(); ++ net.minecraft.world.entity.Entity entity = this.getHandle().getCustomEventDamager(); // Paper + return (entity != null) ? entity.getBukkitEntity() : null; + } + @Override public org.bukkit.entity.Entity getDirectEntity() { - net.minecraft.world.entity.Entity entity = this.getHandle().getDamager(); diff --git a/patches/server/Fix-ItemFlags.patch b/patches/server/Fix-ItemFlags.patch index c0ae735d8e..d640951e50 100644 --- a/patches/server/Fix-ItemFlags.patch +++ b/patches/server/Fix-ItemFlags.patch @@ -82,23 +82,22 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 Set, Optional>> keys = tag.entrySet(); for (Map.Entry, Optional> key : keys) { @@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta { - ByteArrayInputStream buf = new ByteArrayInputStream(Base64.getDecoder().decode(unhandled)); try { CompoundTag unhandledTag = NbtIo.readCompressed(buf, NbtAccounter.unlimitedHeap()); -- this.unhandledTags.copy(DataComponentPatch.CODEC.parse(MinecraftServer.getDefaultRegistryAccess().createSerializationContext(NbtOps.INSTANCE), unhandledTag).result().get()); + DataComponentPatch unhandledPatch = DataComponentPatch.CODEC.parse(MinecraftServer.getDefaultRegistryAccess().createSerializationContext(NbtOps.INSTANCE), unhandledTag).result().get(); +- this.unhandledTags.copy(unhandledPatch); + // Paper start -+ final net.minecraft.core.component.DataComponentPatch patch = net.minecraft.core.component.DataComponentPatch.CODEC.parse(net.minecraft.server.MinecraftServer.getDefaultRegistryAccess().createSerializationContext(net.minecraft.nbt.NbtOps.INSTANCE), unhandledTag).result().get(); -+ CraftMetaItem.getOrEmpty(patch, CraftMetaItem.CAN_PLACE_ON).ifPresent(data -> { ++ CraftMetaItem.getOrEmpty(unhandledPatch, CraftMetaItem.CAN_PLACE_ON).ifPresent(data -> { + this.canPlaceOnPredicates = List.copyOf(data.predicates); + }); -+ CraftMetaItem.getOrEmpty(patch, CraftMetaItem.CAN_BREAK).ifPresent(data -> { ++ CraftMetaItem.getOrEmpty(unhandledPatch, CraftMetaItem.CAN_BREAK).ifPresent(data -> { + this.canBreakPredicates = List.copyOf(data.predicates); + }); -+ this.unhandledTags.copy(patch.forget(type -> type == CraftMetaItem.CAN_PLACE_ON.TYPE || type == CraftMetaItem.CAN_BREAK.TYPE)); ++ this.unhandledTags.copy(unhandledPatch.forget(type -> type == CraftMetaItem.CAN_PLACE_ON.TYPE || type == CraftMetaItem.CAN_BREAK.TYPE)); + // Paper end - } catch (IOException ex) { - Logger.getLogger(CraftMetaItem.class.getName()).log(Level.SEVERE, null, ex); - } + + for (Entry, Optional> entry : unhandledPatch.entrySet()) { + // Move removed unhandled tags to dedicated removedTags @@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta { itemTag.put(CraftMetaItem.MAX_DAMAGE, this.maxDamage); } @@ -119,8 +118,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 @Overridden boolean isEmpty() { -- return !(this.hasDisplayName() || this.hasItemName() || this.hasLocalizedName() || this.hasEnchants() || (this.lore != null) || this.hasCustomModelData() || this.hasBlockData() || this.hasRepairCost() || !this.unhandledTags.build().isEmpty() || !this.persistentDataContainer.isEmpty() || this.hideFlag != 0 || this.isHideTooltip() || this.isUnbreakable() || this.hasEnchantmentGlintOverride() || this.isFireResistant() || this.hasMaxStackSize() || this.hasRarity() || this.hasFood() || this.hasTool() || this.hasDamage() || this.hasMaxDamage() || this.hasAttributeModifiers() || this.customTag != null); -+ return !(this.hasDisplayName() || this.hasItemName() || this.hasLocalizedName() || this.hasEnchants() || (this.lore != null) || this.hasCustomModelData() || this.hasBlockData() || this.hasRepairCost() || !this.unhandledTags.build().isEmpty() || !this.persistentDataContainer.isEmpty() || this.hideFlag != 0 || this.isHideTooltip() || this.isUnbreakable() || this.hasEnchantmentGlintOverride() || this.isFireResistant() || this.hasMaxStackSize() || this.hasRarity() || this.hasFood() || this.hasTool() || this.hasDamage() || this.hasMaxDamage() || this.hasAttributeModifiers() || this.customTag != null || this.canPlaceOnPredicates != null || this.canBreakPredicates != null); // Paper +- return !(this.hasDisplayName() || this.hasItemName() || this.hasLocalizedName() || this.hasEnchants() || (this.lore != null) || this.hasCustomModelData() || this.hasBlockData() || this.hasRepairCost() || !this.unhandledTags.build().isEmpty() || !this.removedTags.isEmpty() || !this.persistentDataContainer.isEmpty() || this.hideFlag != 0 || this.isHideTooltip() || this.isUnbreakable() || this.hasEnchantmentGlintOverride() || this.isFireResistant() || this.hasMaxStackSize() || this.hasRarity() || this.hasFood() || this.hasTool() || this.hasDamage() || this.hasMaxDamage() || this.hasAttributeModifiers() || this.customTag != null); ++ return !(this.hasDisplayName() || this.hasItemName() || this.hasLocalizedName() || this.hasEnchants() || (this.lore != null) || this.hasCustomModelData() || this.hasBlockData() || this.hasRepairCost() || !this.unhandledTags.build().isEmpty() || !this.removedTags.isEmpty() || !this.persistentDataContainer.isEmpty() || this.hideFlag != 0 || this.isHideTooltip() || this.isUnbreakable() || this.hasEnchantmentGlintOverride() || this.isFireResistant() || this.hasMaxStackSize() || this.hasRarity() || this.hasFood() || this.hasTool() || this.hasDamage() || this.hasMaxDamage() || this.hasAttributeModifiers() || this.customTag != null || this.canPlaceOnPredicates != null || this.canBreakPredicates != null); // Paper } // Paper start @@ -187,8 +186,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + } + // Paper end - if (!this.persistentDataContainer.isEmpty()) { // Store custom tags, wrapped in their compound - builder.put(CraftMetaItem.BUKKIT_CUSTOM_TAG.BUKKIT, this.persistentDataContainer.serialize()); + if (!this.removedTags.isEmpty()) { + RegistryAccess registryAccess = CraftRegistry.getMinecraftRegistry(); @@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta { CraftMetaItem.MAX_DAMAGE.TYPE, CraftMetaItem.CUSTOM_DATA.TYPE, diff --git a/patches/server/General-ItemMeta-fixes.patch b/patches/server/General-ItemMeta-fixes.patch index c91b9bbf7c..6b6c15f5ec 100644 --- a/patches/server/General-ItemMeta-fixes.patch +++ b/patches/server/General-ItemMeta-fixes.patch @@ -358,8 +358,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 } @Override -@@ -0,0 +0,0 @@ public class CraftMetaBlockState extends CraftMetaItem implements BlockStateMeta - @Override public CraftMetaBlockState clone() { CraftMetaBlockState meta = (CraftMetaBlockState) super.clone(); - if (this.blockEntityTag != null) { @@ -531,9 +529,9 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaColorableAr index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaColorableArmor.java +++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaColorableArmor.java -@@ -0,0 +0,0 @@ public class CraftMetaColorableArmor extends CraftMetaArmor implements Colorable - Material.WOLF_ARMOR - ); +@@ -0,0 +0,0 @@ import org.bukkit.inventory.meta.ColorableArmorMeta; + @DelegateDeserialization(SerializableMeta.class) + public class CraftMetaColorableArmor extends CraftMetaArmor implements ColorableArmorMeta { - private Color color = DEFAULT_LEATHER_COLOR; + private Integer color; // Paper - keep color component consistent with vanilla (top byte is ignored) @@ -889,15 +887,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 return; } -@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta { - - @Overridden - boolean isEmpty() { -- return !(this.hasDisplayName() || this.hasItemName() || this.hasLocalizedName() || this.hasEnchants() || (this.lore != null) || this.hasCustomModelData() || this.hasBlockData() || this.hasRepairCost() || !this.unhandledTags.build().isEmpty() || !this.persistentDataContainer.isEmpty() || this.hideFlag != 0 || this.isHideTooltip() || this.isUnbreakable() || this.hasEnchantmentGlintOverride() || this.isFireResistant() || this.hasMaxStackSize() || this.hasRarity() || this.hasFood() || this.hasTool() || this.hasDamage() || this.hasMaxDamage() || this.hasAttributeModifiers() || this.customTag != null || this.canPlaceOnPredicates != null || this.canBreakPredicates != null); // Paper -+ return !(this.hasDisplayName() || this.hasItemName() || this.hasLocalizedName() || this.hasEnchants() || (this.lore != null) || this.hasCustomModelData() || this.hasBlockData() || this.hasRepairCost() || !this.unhandledTags.build().isEmpty() || !this.persistentDataContainer.isEmpty() || this.hideFlag != 0 || this.isHideTooltip() || this.isUnbreakable() || this.hasEnchantmentGlintOverride() || this.isFireResistant() || this.hasMaxStackSize() || this.hasRarity() || this.hasFood() || this.hasTool() || this.hasDamage() || this.hasMaxDamage() || this.attributeModifiers != null || this.customTag != null || this.canPlaceOnPredicates != null || this.canBreakPredicates != null); // Paper - } - - // Paper start @@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta { @Override @@ -1059,8 +1048,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 - && (this.hasAttributeModifiers() ? that.hasAttributeModifiers() && CraftMetaItem.compareModifiers(this.attributeModifiers, that.attributeModifiers) : !that.hasAttributeModifiers()) + && (this.attributeModifiers != null ? that.attributeModifiers != null && CraftMetaItem.compareModifiers(this.attributeModifiers, that.attributeModifiers) : that.attributeModifiers == null) // Paper - track only null modifiers && (this.unhandledTags.equals(that.unhandledTags)) + && (this.removedTags.equals(that.removedTags)) && (Objects.equals(this.customTag, that.customTag)) - && (this.persistentDataContainer.equals(that.persistentDataContainer)) @@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta { hash = 61 * hash + (this.hasTool() ? this.tool.hashCode() : 0); hash = 61 * hash + (this.hasJukeboxPlayable() ? this.jukebox.hashCode() : 0); diff --git a/patches/server/MC-Utils.patch b/patches/server/MC-Utils.patch index e4147f1444..89cb5d9189 100644 --- a/patches/server/MC-Utils.patch +++ b/patches/server/MC-Utils.patch @@ -6189,7 +6189,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + // Paper end // CraftBukkit start public LevelChunk getFullChunkNow() { - return (LevelChunk) this.getChunkIfPresent(ChunkStatus.FULL); + // Note: We use the oldTicketLevel for isLoaded checks. @@ -0,0 +0,0 @@ public class ChunkHolder extends GenerationChunkHolder { } // CraftBukkit end diff --git a/patches/server/More-Projectile-API.patch b/patches/server/More-Projectile-API.patch index 7a0f23277a..73da568dc1 100644 --- a/patches/server/More-Projectile-API.patch +++ b/patches/server/More-Projectile-API.patch @@ -395,7 +395,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 @Override public FireworkMeta getFireworkMeta() { - return (FireworkMeta) this.item.getItemMeta(); -+ return (FireworkMeta) CraftItemStack.getItemMeta(this.getHandle().getEntityData().get(FireworkRocketEntity.DATA_ID_FIREWORKS_ITEM), Material.FIREWORK_ROCKET); // Paper - Expose firework item directly ++ return (FireworkMeta) CraftItemStack.getItemMeta(this.getHandle().getEntityData().get(FireworkRocketEntity.DATA_ID_FIREWORKS_ITEM), org.bukkit.inventory.ItemType.FIREWORK_ROCKET); // Paper - Expose firework item directly } @Override @@ -643,7 +643,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + // Paper start - Projectile API + @Override + public org.bukkit.inventory.meta.PotionMeta getPotionMeta() { -+ return (org.bukkit.inventory.meta.PotionMeta) CraftItemStack.getItemMeta(this.getHandle().getItem(), Material.SPLASH_POTION); ++ return (org.bukkit.inventory.meta.PotionMeta) CraftItemStack.getItemMeta(this.getHandle().getItem(), org.bukkit.inventory.ItemType.SPLASH_POTION); + } + + @Override @@ -748,16 +748,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + } public static ItemMeta getItemMeta(net.minecraft.world.item.ItemStack item) { -+ return getItemMeta(item, CraftItemStack.getType(item)); ++ return getItemMeta(item, null); + } -+ public static ItemMeta getItemMeta(net.minecraft.world.item.ItemStack item, Material material) { ++ public static ItemMeta getItemMeta(net.minecraft.world.item.ItemStack item, org.bukkit.inventory.ItemType metaForType) { + // Paper end if (!CraftItemStack.hasItemMeta(item)) { -- return CraftItemFactory.instance().getItemMeta(CraftItemStack.getType(item)); -+ return CraftItemFactory.instance().getItemMeta(material); // Paper + return CraftItemFactory.instance().getItemMeta(CraftItemStack.getType(item)); } -- switch (CraftItemStack.getType(item)) { -+ switch (material) { // Paper - case WRITTEN_BOOK: - return new CraftMetaBookSigned(item.getComponentsPatch()); - case WRITABLE_BOOK: + ++ if (metaForType != null) { return ((CraftItemType) metaForType).getItemMeta(item); } // Paper + return ((CraftItemType) CraftItemType.minecraftToBukkitNew(item.getItem())).getItemMeta(item); + } + diff --git a/patches/server/More-Teleport-API.patch b/patches/server/More-Teleport-API.patch index d193ee95b7..e28d21536f 100644 --- a/patches/server/More-Teleport-API.patch +++ b/patches/server/More-Teleport-API.patch @@ -9,7 +9,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl - return false; // CraftBukkit - Return event status + return true; // CraftBukkit - Return event status } - PlayerTeleportEvent event = new PlayerTeleportEvent(player, from.clone(), to.clone(), cause); diff --git a/patches/server/Test-changes.patch b/patches/server/Test-changes.patch index 09d9291418..64747ee059 100644 --- a/patches/server/Test-changes.patch +++ b/patches/server/Test-changes.patch @@ -355,7 +355,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 --- a/src/test/java/org/bukkit/support/DummyServer.java +++ b/src/test/java/org/bukkit/support/DummyServer.java @@ -0,0 +0,0 @@ public final class DummyServer { - return registers.computeIfAbsent(aClass, key -> CraftRegistry.createRegistry(aClass, AbstractTestingBase.REGISTRY_CUSTOM)); + return null; }); + // Paper start - testing additions diff --git a/patches/server/fix-item-meta-for-tadpole-buckets.patch b/patches/server/fix-item-meta-for-tadpole-buckets.patch index 5d005cd47f..4dd562928b 100644 --- a/patches/server/fix-item-meta-for-tadpole-buckets.patch +++ b/patches/server/fix-item-meta-for-tadpole-buckets.patch @@ -4,30 +4,19 @@ Date: Tue, 11 Jul 2023 11:22:30 -0700 Subject: [PATCH] fix item meta for tadpole buckets -diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java +diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 ---- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java -+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java -@@ -0,0 +0,0 @@ public final class CraftItemFactory implements ItemFactory { - case COD_BUCKET: - case PUFFERFISH_BUCKET: - case SALMON_BUCKET: -+ case TADPOLE_BUCKET: // Paper - case ITEM_FRAME: - case GLOW_ITEM_FRAME: - case PAINTING: -diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java -index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 ---- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java -+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java -@@ -0,0 +0,0 @@ public final class CraftItemStack extends ItemStack { - case COD_BUCKET: - case PUFFERFISH_BUCKET: - case SALMON_BUCKET: -+ case TADPOLE_BUCKET: // Paper - case ITEM_FRAME: - case GLOW_ITEM_FRAME: - case PAINTING: +--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java ++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java +@@ -0,0 +0,0 @@ public final class CraftItemMetas { + if (itemType == ItemType.SUSPICIOUS_STEW) { + return CraftItemMetas.asType(CraftItemMetas.SUSPICIOUS_STEW_META_DATA); + } +- if (itemType == ItemType.COD_BUCKET || itemType == ItemType.PUFFERFISH_BUCKET ++ if (itemType == ItemType.COD_BUCKET || itemType == ItemType.PUFFERFISH_BUCKET || itemType == ItemType.TADPOLE_BUCKET // Paper + || itemType == ItemType.SALMON_BUCKET || itemType == ItemType.ITEM_FRAME + || itemType == ItemType.GLOW_ITEM_FRAME || itemType == ItemType.PAINTING) { + return CraftItemMetas.asType(CraftItemMetas.ENTITY_TAG_META_DATA); diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaEntityTag.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaEntityTag.java index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaEntityTag.java diff --git a/patches/server/improve-checking-handled-tags-in-itemmeta.patch b/patches/server/improve-checking-handled-tags-in-itemmeta.patch index 6440d1d2c7..c3655cc245 100644 --- a/patches/server/improve-checking-handled-tags-in-itemmeta.patch +++ b/patches/server/improve-checking-handled-tags-in-itemmeta.patch @@ -4,6 +4,155 @@ Date: Mon, 10 Jul 2023 16:10:15 -0700 Subject: [PATCH] improve checking handled tags in itemmeta +diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java +index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 +--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java ++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java +@@ -0,0 +0,0 @@ import org.bukkit.inventory.meta.TropicalFishBucketMeta; + + public final class CraftItemMetas { + +- public record ItemMetaData(Class metaClass, Function fromItemStack, ++ public record ItemMetaData(Class metaClass, BiFunction>, I> fromItemStack, + BiFunction, CraftMetaItem, I> fromItemMeta) { + } + + private static final ItemMetaData EMPTY_META_DATA = new ItemMetaData<>(ItemMeta.class, +- item -> null, ++ (item, extras) -> null, + (type, meta) -> null); + + private static final ItemMetaData ITEM_META_DATA = new ItemMetaData<>(ItemMeta.class, +- item -> new CraftMetaItem(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaItem(item.getComponentsPatch(), extras), + (type, meta) -> new CraftMetaItem(meta)); + + private static final ItemMetaData SIGNED_BOOK_META_DATA = new ItemMetaData<>(BookMeta.class, +- item -> new CraftMetaBookSigned(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaBookSigned(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaBookSigned signed ? signed : new CraftMetaBookSigned(meta)); + + private static final ItemMetaData WRITABLE_BOOK_META_DATA = new ItemMetaData<>(BookMeta.class, +- item -> new CraftMetaBook(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaBook(item.getComponentsPatch(), extras), + (type, meta) -> meta != null && meta.getClass().equals(CraftMetaBook.class) ? (BookMeta) meta : new CraftMetaBook(meta)); + + private static final ItemMetaData SKULL_META_DATA = new ItemMetaData<>(SkullMeta.class, +- item -> new CraftMetaSkull(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaSkull(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaSkull skull ? skull : new CraftMetaSkull(meta)); + + private static final ItemMetaData ARMOR_META_DATA = new ItemMetaData<>(ArmorMeta.class, +- item -> new CraftMetaArmor(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaArmor(item.getComponentsPatch(), extras), + (type, meta) -> meta != null && meta.getClass().equals(CraftMetaArmor.class) ? (ArmorMeta) meta : new CraftMetaArmor(meta)); + + private static final ItemMetaData COLORABLE_ARMOR_META_DATA = new ItemMetaData<>(ColorableArmorMeta.class, +- item -> new CraftMetaColorableArmor(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaColorableArmor(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof ColorableArmorMeta colorable ? colorable : new CraftMetaColorableArmor(meta)); + + private static final ItemMetaData LEATHER_ARMOR_META_DATA = new ItemMetaData<>(LeatherArmorMeta.class, +- item -> new CraftMetaLeatherArmor(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaLeatherArmor(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaLeatherArmor leather ? leather : new CraftMetaLeatherArmor(meta)); + + private static final ItemMetaData POTION_META_DATA = new ItemMetaData<>(PotionMeta.class, +- item -> new CraftMetaPotion(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaPotion(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaPotion potion ? potion : new CraftMetaPotion(meta)); + + private static final ItemMetaData MAP_META_DATA = new ItemMetaData<>(MapMeta.class, +- item -> new CraftMetaMap(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaMap(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaMap map ? map : new CraftMetaMap(meta)); + + private static final ItemMetaData FIREWORK_META_DATA = new ItemMetaData<>(FireworkMeta.class, +- item -> new CraftMetaFirework(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaFirework(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaFirework firework ? firework : new CraftMetaFirework(meta)); + + private static final ItemMetaData CHARGE_META_DATA = new ItemMetaData<>(FireworkEffectMeta.class, +- item -> new CraftMetaCharge(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaCharge(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaCharge charge ? charge : new CraftMetaCharge(meta)); + + private static final ItemMetaData ENCHANTED_BOOK_META_DATA = new ItemMetaData<>(EnchantmentStorageMeta.class, +- item -> new CraftMetaEnchantedBook(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaEnchantedBook(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaEnchantedBook enchantedBook ? enchantedBook : new CraftMetaEnchantedBook(meta)); + + private static final ItemMetaData BANNER_META_DATA = new ItemMetaData<>(BannerMeta.class, +- item -> new CraftMetaBanner(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaBanner(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaBanner banner ? banner : new CraftMetaBanner(meta)); + + private static final ItemMetaData SPAWN_EGG_META_DATA = new ItemMetaData<>(SpawnEggMeta.class, +- item -> new CraftMetaSpawnEgg(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaSpawnEgg(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaSpawnEgg spawnEgg ? spawnEgg : new CraftMetaSpawnEgg(meta)); + + private static final ItemMetaData ARMOR_STAND_META_DATA = new ItemMetaData<>(ArmorStandMeta.class, // paper +- item -> new CraftMetaArmorStand(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaArmorStand(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaArmorStand armorStand ? armorStand : new CraftMetaArmorStand(meta)); + + private static final ItemMetaData KNOWLEDGE_BOOK_META_DATA = new ItemMetaData<>(KnowledgeBookMeta.class, +- item -> new CraftMetaKnowledgeBook(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaKnowledgeBook(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaKnowledgeBook knowledgeBook ? knowledgeBook : new CraftMetaKnowledgeBook(meta)); + + private static final ItemMetaData BLOCK_STATE_META_DATA = new ItemMetaData<>(BlockStateMeta.class, +- item -> new CraftMetaBlockState(item.getComponentsPatch(), CraftItemType.minecraftToBukkit(item.getItem())), ++ (item, extras) -> new CraftMetaBlockState(item.getComponentsPatch(), CraftItemType.minecraftToBukkit(item.getItem()), extras), + (type, meta) -> new CraftMetaBlockState(meta, type.asMaterial())); + + private static final ItemMetaData TROPICAL_FISH_BUCKET_META_DATA = new ItemMetaData<>(TropicalFishBucketMeta.class, +- item -> new CraftMetaTropicalFishBucket(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaTropicalFishBucket(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaTropicalFishBucket tropicalFishBucket ? tropicalFishBucket : new CraftMetaTropicalFishBucket(meta)); + + private static final ItemMetaData AXOLOTL_BUCKET_META_DATA = new ItemMetaData<>(AxolotlBucketMeta.class, +- item -> new CraftMetaAxolotlBucket(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaAxolotlBucket(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaAxolotlBucket axolotlBucket ? axolotlBucket : new CraftMetaAxolotlBucket(meta)); + + private static final ItemMetaData CROSSBOW_META_DATA = new ItemMetaData<>(CrossbowMeta.class, +- item -> new CraftMetaCrossbow(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaCrossbow(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaCrossbow crossbow ? crossbow : new CraftMetaCrossbow(meta)); + + private static final ItemMetaData SUSPICIOUS_STEW_META_DATA = new ItemMetaData<>(SuspiciousStewMeta.class, +- item -> new CraftMetaSuspiciousStew(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaSuspiciousStew(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaSuspiciousStew suspiciousStew ? suspiciousStew : new CraftMetaSuspiciousStew(meta)); + + private static final ItemMetaData ENTITY_TAG_META_DATA = new ItemMetaData<>(ItemMeta.class, +- item -> new CraftMetaEntityTag(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaEntityTag(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaEntityTag entityTag ? entityTag : new CraftMetaEntityTag(meta)); + + private static final ItemMetaData COMPASS_META_DATA = new ItemMetaData<>(CompassMeta.class, +- item -> new CraftMetaCompass(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaCompass(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaCompass compass ? compass : new CraftMetaCompass(meta)); + + private static final ItemMetaData BUNDLE_META_DATA = new ItemMetaData<>(BundleMeta.class, +- item -> new CraftMetaBundle(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaBundle(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaBundle bundle ? bundle : new CraftMetaBundle(meta)); + + private static final ItemMetaData MUSIC_INSTRUMENT_META_DATA = new ItemMetaData<>(MusicInstrumentMeta.class, +- item -> new CraftMetaMusicInstrument(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaMusicInstrument(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaMusicInstrument musicInstrument ? musicInstrument : new CraftMetaMusicInstrument(meta)); + + private static final ItemMetaData OMINOUS_BOTTLE_META_DATA = new ItemMetaData<>(OminousBottleMeta.class, +- item -> new CraftMetaOminousBottle(item.getComponentsPatch()), ++ (item, extras) -> new CraftMetaOminousBottle(item.getComponentsPatch(), extras), + (type, meta) -> meta instanceof CraftMetaOminousBottle musicInstrument ? musicInstrument : new CraftMetaOminousBottle(meta)); + + // We use if instead of a set, since the result gets cached in CraftItemType, diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java @@ -33,7 +182,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + newMeta = getItemMeta(this.handle); + } else { + final java.util.Set> extraHandledDcts = new java.util.HashSet<>(CraftMetaItem.getTopLevelHandledDcts(oldMeta.getClass())); -+ newMeta = getItemMeta(this.handle, CraftItemStack.getType(this.handle), extraHandledDcts); ++ newMeta = getItemMeta(this.handle, CraftItemType.minecraftToBukkitNew(this.handle.getItem()), extraHandledDcts); + } + this.setItemMeta(newMeta); + } @@ -43,141 +192,39 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 final CraftMetaItem.Applicator tag = new CraftMetaItem.Applicator(); @@ -0,0 +0,0 @@ public final class CraftItemStack extends ItemStack { } - public static ItemMeta getItemMeta(net.minecraft.world.item.ItemStack item, Material material) { + public static ItemMeta getItemMeta(net.minecraft.world.item.ItemStack item, org.bukkit.inventory.ItemType metaForType) { // Paper end + // Paper start - handled tags on type change -+ return getItemMeta(item, material, null); ++ return getItemMeta(item, metaForType, null); + } -+ public static ItemMeta getItemMeta(net.minecraft.world.item.ItemStack item, Material material, final java.util.Set> extraHandledDcts) { ++ public static ItemMeta getItemMeta(net.minecraft.world.item.ItemStack item, org.bukkit.inventory.ItemType metaForType, final java.util.Set> extraHandledDcts) { + // Paper end - handled tags on type change if (!CraftItemStack.hasItemMeta(item)) { - return CraftItemFactory.instance().getItemMeta(material); // Paper - } - switch (material) { // Paper - case WRITTEN_BOOK: -- return new CraftMetaBookSigned(item.getComponentsPatch()); -+ return new CraftMetaBookSigned(item.getComponentsPatch(), extraHandledDcts); // Paper - case WRITABLE_BOOK: -- return new CraftMetaBook(item.getComponentsPatch()); -+ return new CraftMetaBook(item.getComponentsPatch(), extraHandledDcts); // Paper - case CREEPER_HEAD: - case CREEPER_WALL_HEAD: - case DRAGON_HEAD: -@@ -0,0 +0,0 @@ public final class CraftItemStack extends ItemStack { - case WITHER_SKELETON_WALL_SKULL: - case ZOMBIE_HEAD: - case ZOMBIE_WALL_HEAD: -- return new CraftMetaSkull(item.getComponentsPatch()); -+ return new CraftMetaSkull(item.getComponentsPatch(), extraHandledDcts); // Paper - case CHAINMAIL_HELMET: - case CHAINMAIL_CHESTPLATE: - case CHAINMAIL_LEGGINGS: -@@ -0,0 +0,0 @@ public final class CraftItemStack extends ItemStack { - case NETHERITE_LEGGINGS: - case NETHERITE_BOOTS: - case TURTLE_HELMET: -- return new CraftMetaArmor(item.getComponentsPatch()); -+ return new CraftMetaArmor(item.getComponentsPatch(), extraHandledDcts); // Paper - case LEATHER_HELMET: - case LEATHER_CHESTPLATE: - case LEATHER_LEGGINGS: - case LEATHER_BOOTS: - case WOLF_ARMOR: -- return new CraftMetaColorableArmor(item.getComponentsPatch()); -+ return new CraftMetaColorableArmor(item.getComponentsPatch(), extraHandledDcts); // Paper - case LEATHER_HORSE_ARMOR: -- return new CraftMetaLeatherArmor(item.getComponentsPatch()); -+ return new CraftMetaLeatherArmor(item.getComponentsPatch(), extraHandledDcts); // Paper - case POTION: - case SPLASH_POTION: - case LINGERING_POTION: - case TIPPED_ARROW: -- return new CraftMetaPotion(item.getComponentsPatch()); -+ return new CraftMetaPotion(item.getComponentsPatch(), extraHandledDcts); // Paper - case FILLED_MAP: -- return new CraftMetaMap(item.getComponentsPatch()); -+ return new CraftMetaMap(item.getComponentsPatch(), extraHandledDcts); // Paper - case FIREWORK_ROCKET: -- return new CraftMetaFirework(item.getComponentsPatch()); -+ return new CraftMetaFirework(item.getComponentsPatch(), extraHandledDcts); // Paper - case FIREWORK_STAR: -- return new CraftMetaCharge(item.getComponentsPatch()); -+ return new CraftMetaCharge(item.getComponentsPatch(), extraHandledDcts); // Paper; - case ENCHANTED_BOOK: -- return new CraftMetaEnchantedBook(item.getComponentsPatch()); -+ return new CraftMetaEnchantedBook(item.getComponentsPatch(), extraHandledDcts); // Paper - case BLACK_BANNER: - case BLACK_WALL_BANNER: - case BLUE_BANNER: -@@ -0,0 +0,0 @@ public final class CraftItemStack extends ItemStack { - case WHITE_WALL_BANNER: - case YELLOW_BANNER: - case YELLOW_WALL_BANNER: -- return new CraftMetaBanner(item.getComponentsPatch()); -+ return new CraftMetaBanner(item.getComponentsPatch(), extraHandledDcts); // Paper - case ARMADILLO_SPAWN_EGG: - case ALLAY_SPAWN_EGG: - case AXOLOTL_SPAWN_EGG: -@@ -0,0 +0,0 @@ public final class CraftItemStack extends ItemStack { - case ZOMBIE_SPAWN_EGG: - case ZOMBIE_VILLAGER_SPAWN_EGG: - case ZOMBIFIED_PIGLIN_SPAWN_EGG: -- return new CraftMetaSpawnEgg(item.getComponentsPatch()); -+ return new CraftMetaSpawnEgg(item.getComponentsPatch(), extraHandledDcts); // Paper - case ARMOR_STAND: -- return new CraftMetaArmorStand(item.getComponentsPatch()); -+ return new CraftMetaArmorStand(item.getComponentsPatch(), extraHandledDcts); // Paper - case KNOWLEDGE_BOOK: -- return new CraftMetaKnowledgeBook(item.getComponentsPatch()); -+ return new CraftMetaKnowledgeBook(item.getComponentsPatch(), extraHandledDcts); // Paper - case FURNACE: - case CHEST: - case TRAPPED_CHEST: -@@ -0,0 +0,0 @@ public final class CraftItemStack extends ItemStack { - case CRAFTER: - case TRIAL_SPAWNER: - case VAULT: -- return new CraftMetaBlockState(item.getComponentsPatch(), CraftItemType.minecraftToBukkit(item.getItem())); -+ return new CraftMetaBlockState(item.getComponentsPatch(), CraftItemType.minecraftToBukkit(item.getItem()), extraHandledDcts); // Paper - case TROPICAL_FISH_BUCKET: -- return new CraftMetaTropicalFishBucket(item.getComponentsPatch()); -+ return new CraftMetaTropicalFishBucket(item.getComponentsPatch(), extraHandledDcts); // Paper - case AXOLOTL_BUCKET: -- return new CraftMetaAxolotlBucket(item.getComponentsPatch()); -+ return new CraftMetaAxolotlBucket(item.getComponentsPatch(), extraHandledDcts); // Paper - case CROSSBOW: -- return new CraftMetaCrossbow(item.getComponentsPatch()); -+ return new CraftMetaCrossbow(item.getComponentsPatch(), extraHandledDcts); // Paper - case SUSPICIOUS_STEW: -- return new CraftMetaSuspiciousStew(item.getComponentsPatch()); -+ return new CraftMetaSuspiciousStew(item.getComponentsPatch(), extraHandledDcts); // Paper - case COD_BUCKET: - case PUFFERFISH_BUCKET: - case SALMON_BUCKET: -@@ -0,0 +0,0 @@ public final class CraftItemStack extends ItemStack { - case ITEM_FRAME: - case GLOW_ITEM_FRAME: - case PAINTING: -- return new CraftMetaEntityTag(item.getComponentsPatch()); -+ return new CraftMetaEntityTag(item.getComponentsPatch(), extraHandledDcts); // Paper - case COMPASS: -- return new CraftMetaCompass(item.getComponentsPatch()); -+ return new CraftMetaCompass(item.getComponentsPatch(), extraHandledDcts); // Paper - case BUNDLE: -- return new CraftMetaBundle(item.getComponentsPatch()); -+ return new CraftMetaBundle(item.getComponentsPatch(), extraHandledDcts); // Paper - case GOAT_HORN: -- return new CraftMetaMusicInstrument(item.getComponentsPatch()); -+ return new CraftMetaMusicInstrument(item.getComponentsPatch(), extraHandledDcts); // Paper - case OMINOUS_BOTTLE: -- return new CraftMetaOminousBottle(item.getComponentsPatch()); -+ return new CraftMetaOminousBottle(item.getComponentsPatch(), extraHandledDcts); // Paper - default: -- return new CraftMetaItem(item.getComponentsPatch()); -+ return new CraftMetaItem(item.getComponentsPatch(), extraHandledDcts); // Paper + return CraftItemFactory.instance().getItemMeta(CraftItemStack.getType(item)); } + +- if (metaForType != null) { return ((CraftItemType) metaForType).getItemMeta(item); } // Paper +- return ((CraftItemType) CraftItemType.minecraftToBukkitNew(item.getItem())).getItemMeta(item); ++ if (metaForType != null) { return ((CraftItemType) metaForType).getItemMeta(item, extraHandledDcts); } // Paper ++ return ((CraftItemType) CraftItemType.minecraftToBukkitNew(item.getItem())).getItemMeta(item, extraHandledDcts); // Paper } + static Material getType(net.minecraft.world.item.ItemStack item) { +diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemType.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemType.java +index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 +--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemType.java ++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemType.java +@@ -0,0 +0,0 @@ public class CraftItemType implements ItemType.Typed, Han + return this.item; + } + +- public M getItemMeta(net.minecraft.world.item.ItemStack itemStack) { +- return this.itemMetaData.get().fromItemStack().apply(itemStack); ++ public M getItemMeta(net.minecraft.world.item.ItemStack itemStack, final java.util.Set> extraHandledDcts) { ++ return this.itemMetaData.get().fromItemStack().apply(itemStack, extraHandledDcts); + } + + public M getItemMeta(ItemMeta itemMeta) { diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaArmor.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaArmor.java index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 --- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaArmor.java @@ -429,13 +476,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000 + // Paper end - improve checking handled data component types Set, Optional>> keys = tag.entrySet(); for (Map.Entry, Optional> key : keys) { + // Paper start - don't lose unhandled tags if (key.getValue().isEmpty()) { this.unhandledTags.remove(key.getKey()); - } else if (!CraftMetaItem.getHandledTags().contains(key.getKey())) { + } else if (!handledTags.contains(key.getKey())) { // Paper - improve checking handled data component types - key.getValue().ifPresentOrElse((value) -> { + // Paper end - don't lose unhandled tags + key.getValue().ifPresent((value) -> { this.unhandledTags.set((DataComponentType) key.getKey(), value); - }, () -> { @@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta { this.version = version; } diff --git a/work/Bukkit b/work/Bukkit index befcf86d22..e2160a1865 160000 --- a/work/Bukkit +++ b/work/Bukkit @@ -1 +1 @@ -Subproject commit befcf86d22f9576c361bba18b2ec725e41508a65 +Subproject commit e2160a18658bb7d19d303abd7a24605848d6912c diff --git a/work/CraftBukkit b/work/CraftBukkit index a1d2cd1521..6ce1726424 160000 --- a/work/CraftBukkit +++ b/work/CraftBukkit @@ -1 +1 @@ -Subproject commit a1d2cd1521b97cb4048f990455d78e7c9fb94e82 +Subproject commit 6ce17264243172b5e3d14309388e131f025d90f4