666 plus 1

patches/server/Add-BlockBreakBlockEvent.patch

@@ -44,7 +44,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -                dropResources(iblockdata1, world, blockposition3, tileentity);
 +                dropResources(iblockdata1, world, blockposition3, tileentity, pos); // Paper - Add BlockBreakBlockEvent
                  world.setBlock(blockposition3, Blocks.AIR.defaultBlockState(), 18);
-                 world.gameEvent(GameEvent.BLOCK_DESTROY, blockposition3, GameEvent.Context.of(iblockdata1));
+                 world.gameEvent((Holder) GameEvent.BLOCK_DESTROY, blockposition3, GameEvent.Context.of(iblockdata1));
                  if (!iblockdata1.is(BlockTags.FIRE)) {
 diff --git a/src/main/java/net/minecraft/world/level/material/FlowingFluid.java b/src/main/java/net/minecraft/world/level/material/FlowingFluid.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644

patches/server/Add-EntityDamageItemEvent.patch

@@ -8,16 +8,16 @@ diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/ja
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- 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 {
-         return this.getItem().getMaxDamage();
+@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
+         return (Integer) this.getOrDefault(DataComponents.MAX_DAMAGE, 0);
      }
  
--    public boolean hurt(int amount, RandomSource random, @Nullable ServerPlayer player) {
-+    public boolean hurt(int amount, RandomSource random, @Nullable LivingEntity player) { // Paper - Add EntityDamageItemEvent
-         if (!this.isDamageableItem()) {
-             return false;
-         } else {
-@@ -0,0 +0,0 @@ public final class ItemStack {
+-    public void hurtAndBreak(int amount, RandomSource random, @Nullable ServerPlayer player, Runnable breakCallback) {
++    public void hurtAndBreak(int amount, RandomSource random, @Nullable LivingEntity player, Runnable breakCallback) { // Paper - Add EntityDamageItemEvent
+         if (this.isDamageableItem()) {
+             int j;
+ 
+@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
  
                  amount -= k;
                  // CraftBukkit start
@@ -28,7 +28,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      event.getPlayer().getServer().getPluginManager().callEvent(event);
  
                      if (amount != event.getDamage() || event.isCancelled()) {
-@@ -0,0 +0,0 @@ public final class ItemStack {
+@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
                      }
  
                      amount = event.getDamage();
@@ -43,7 +43,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  }
                  // CraftBukkit end
                  if (amount <= 0) {
-@@ -0,0 +0,0 @@ public final class ItemStack {
+@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
                  }
              }
  
@@ -54,12 +54,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
  
              j = this.getDamageValue() + amount;
-@@ -0,0 +0,0 @@ public final class ItemStack {
-     public <T extends LivingEntity> void hurtAndBreak(int amount, T entity, Consumer<T> breakCallback) {
-         if (!entity.level().isClientSide && (!(entity instanceof net.minecraft.world.entity.player.Player) || !((net.minecraft.world.entity.player.Player) entity).getAbilities().instabuild)) {
-             if (this.isDamageableItem()) {
--                if (this.hurt(amount, entity.getRandom(), entity instanceof ServerPlayer ? (ServerPlayer) entity : null)) {
-+                if (this.hurt(amount, entity.getRandom(), entity /*instanceof ServerPlayer ? (ServerPlayer) entity : null*/)) { // Paper - Add EntityDamageItemEvent
-                     breakCallback.accept(entity);
-                     Item item = this.getItem();
-                     // CraftBukkit start - Check for item breaking
+@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
+                 entityplayer = null;
+             }
+ 
+-            this.hurtAndBreak(amount, randomsource, entityplayer, () -> {
++            this.hurtAndBreak(amount, randomsource, entity, () -> { // Paper - Add EntityDamageItemEvent
+                 entity.broadcastBreakEvent(slot);
+                 Item item = this.getItem();
+                 // CraftBukkit start - Check for item breaking

patches/server/Add-Raw-Byte-Entity-Serialization.patch

@@ -10,7 +10,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/jav
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          }
      }
  

patches/server/Add-back-EntityPortalExitEvent.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/jav
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
              } else {
                  // CraftBukkit start
                  worldserver = shapedetectorshape.world;
@@ -37,7 +37,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  if (worldserver == this.level) {
                      // SPIGOT-6782: Just move the entity if a plugin changed the world to the one the entity is already in
                      this.moveTo(shapedetectorshape.pos.x, shapedetectorshape.pos.y, shapedetectorshape.pos.z, shapedetectorshape.yRot, shapedetectorshape.xRot);
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
  
                  if (entity != null) {
                      entity.restoreFrom(this);

patches/server/Add-critical-damage-API.patch

@@ -32,32 +32,32 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/player/Player.java
 +++ b/src/main/java/net/minecraft/world/entity/player/Player.java
 @@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
-                         flag1 = true;
-                     }
+                         }
  
--                    boolean flag2 = flag && this.fallDistance > 0.0F && !this.onGround() && !this.onClimbable() && !this.isInWater() && !this.hasEffect(MobEffects.BLINDNESS) && !this.isPassenger() && target instanceof LivingEntity;
-+                    boolean flag2 = flag && this.fallDistance > 0.0F && !this.onGround() && !this.onClimbable() && !this.isInWater() && !this.hasEffect(MobEffects.BLINDNESS) && !this.isPassenger() && target instanceof LivingEntity; // Paper - Add critical damage API; diff on change
+                         f += this.getItemInHand(InteractionHand.MAIN_HAND).getItem().getAttackDamageBonus(this, f);
+-                        boolean flag2 = flag && this.fallDistance > 0.0F && !this.onGround() && !this.onClimbable() && !this.isInWater() && !this.hasEffect(MobEffects.BLINDNESS) && !this.isPassenger() && target instanceof LivingEntity && !this.isSprinting();
++                        boolean flag2 = flag && this.fallDistance > 0.0F && !this.onGround() && !this.onClimbable() && !this.isInWater() && !this.hasEffect(MobEffects.BLINDNESS) && !this.isPassenger() && target instanceof LivingEntity && !this.isSprinting(); // Paper - Add critical damage API; diff on change
  
-                     flag2 = flag2 && !this.level().paperConfig().entities.behavior.disablePlayerCrits; // Paper - Toggleable player crits
-                     flag2 = flag2 && !this.isSprinting();
+                         flag2 = flag2 && !this.level().paperConfig().entities.behavior.disablePlayerCrits; // Paper - Toggleable player crits
+                         if (flag2) {
 @@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
-                     }
+                         }
  
-                     Vec3 vec3d = target.getDeltaMovement();
--                    boolean flag5 = target.hurt(this.damageSources().playerAttack(this), f);
-+                    boolean flag5 = target.hurt(this.damageSources().playerAttack(this).critical(flag2), f); // Paper - add critical damage API
+                         Vec3 vec3d = target.getDeltaMovement();
+-                        boolean flag5 = target.hurt(this.damageSources().playerAttack(this), f);
++                        boolean flag5 = target.hurt(this.damageSources().playerAttack(this).critical(flag2), f); // Paper - add critical damage API
  
-                     if (flag5) {
-                         if (i > 0) {
+                         if (flag5) {
+                             if (i > 0) {
 @@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
  
-                                 if (entityliving != this && entityliving != target && !this.isAlliedTo((Entity) entityliving) && (!(entityliving instanceof ArmorStand) || !((ArmorStand) entityliving).isMarker()) && this.distanceToSqr((Entity) entityliving) < 9.0D) {
-                                     // CraftBukkit start - Only apply knockback if the damage hits
--                                    if (entityliving.hurt(this.damageSources().playerAttack(this).sweep(), f4)) {
-+                                    if (entityliving.hurt(this.damageSources().playerAttack(this).sweep().critical(flag2), f4)) { // Paper - add critical damage API
-                                         entityliving.knockback(0.4000000059604645D, (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)), this, EntityKnockbackEvent.KnockbackCause.SWEEP_ATTACK); // CraftBukkit
-                                     }
-                                     // CraftBukkit end
+                                     if (entityliving != this && entityliving != target && !this.isAlliedTo((Entity) entityliving) && (!(entityliving instanceof ArmorStand) || !((ArmorStand) entityliving).isMarker()) && this.distanceToSqr((Entity) entityliving) < 9.0D) {
+                                         // CraftBukkit start - Only apply knockback if the damage hits
+-                                        if (entityliving.hurt(this.damageSources().playerAttack(this).sweep(), f4)) {
++                                        if (entityliving.hurt(this.damageSources().playerAttack(this).sweep().critical(flag2), f4)) { // Paper - add critical damage API
+                                             entityliving.knockback(0.4000000059604645D, (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)), this, EntityKnockbackEvent.KnockbackCause.SWEEP_ATTACK); // CraftBukkit
+                                         }
+                                         // CraftBukkit end
 diff --git a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
@@ -69,7 +69,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        if (this.isCritArrow()) damagesource = damagesource.critical(); // Paper - add critical damage API
          boolean flag = entity.getType() == EntityType.ENDERMAN;
          int k = entity.getRemainingFireTicks();
-         boolean flag1 = entity.getType().is(EntityTypeTags.DEFLECTS_ARROWS);
+ 
 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

patches/server/Add-isCollidable-methods-to-various-places.patch

@@ -27,8 +27,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockState.java
 +++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockState.java
 @@ -0,0 +0,0 @@ public class CraftBlockState implements BlockState {
-     public CraftBlockState copy() {
-         return new CraftBlockState(this);
+     public BlockState copy(Location location) {
+         return new CraftBlockState(this, location);
      }
 +
 +    // Paper start

patches/server/Add-missing-team-sidebar-display-slots.patch

@@ -8,6 +8,37 @@ public org.bukkit.craftbukkit.scoreboard.CraftScoreboardTranslations
 public org.bukkit.craftbukkit.scoreboard.CraftScoreboardTranslations toBukkitSlot(Lnet/minecraft/world/scores/DisplaySlot;)Lorg/bukkit/scoreboard/DisplaySlot;
 public org.bukkit.craftbukkit.scoreboard.CraftScoreboardTranslations fromBukkitSlot(Lorg/bukkit/scoreboard/DisplaySlot;)Lnet/minecraft/world/scores/DisplaySlot;
 
+diff --git a/src/main/java/org/bukkit/craftbukkit/legacy/FieldRename.java b/src/main/java/org/bukkit/craftbukkit/legacy/FieldRename.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/craftbukkit/legacy/FieldRename.java
++++ b/src/main/java/org/bukkit/craftbukkit/legacy/FieldRename.java
+@@ -0,0 +0,0 @@ public class FieldRename {
+         }
+ 
+         return switch (owner) {
++            case "org/bukkit/scoreboard/DisplaySlot" -> FieldRename.convertDisplaySlot(apiVersion, from); // Paper - DisplaySlot
+             case "org/bukkit/block/banner/PatternType" -> FieldRename.convertPatternTypeName(apiVersion, from);
+             case "org/bukkit/enchantments/Enchantment" -> FieldRename.convertEnchantmentName(apiVersion, from);
+             case "org/bukkit/block/Biome" -> FieldRename.convertBiomeName(apiVersion, from);
+@@ -0,0 +0,0 @@ public class FieldRename {
+         };
+     }
+ 
++    // Paper start - DisplaySlot
++    private static final FieldRenameData DISPLAY_SLOT_DATA = FieldRenameData.Builder.newBuilder()
++        .forAllVersions()
++        .change("SIDEBAR_TEAM_", "SIDEBAR_")
++        .build();
++
++    @DoNotReroute
++    public static String convertDisplaySlot(ApiVersion version, String from) {
++        return FieldRename.DISPLAY_SLOT_DATA.getReplacement(version, from);
++    }
++    // Paper end - DisplaySlot
++
+     // PatternType
+     private static final FieldRenameData PATTERN_TYPE_DATA = FieldRenameData.Builder.newBuilder()
+             .forVersionsBefore(ApiVersion.FIELD_NAME_PARITY)
 diff --git a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardTranslations.java b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardTranslations.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardTranslations.java
@@ -51,26 +82,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          return net.minecraft.world.scores.DisplaySlot.CODEC.byName(CraftScoreboardTranslations.SLOTS.get(slot));
      }
  
-diff --git a/src/main/java/org/bukkit/craftbukkit/util/Commodore.java b/src/main/java/org/bukkit/craftbukkit/util/Commodore.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/util/Commodore.java
-+++ b/src/main/java/org/bukkit/craftbukkit/util/Commodore.java
-@@ -0,0 +0,0 @@ public class Commodore {
-                             desc = getOriginalOrRewrite(desc);
-                         }
-                         // Paper end
-+
-+                        // Paper start - DisplaySlot
-+                        if (owner.equals("org/bukkit/scoreboard/DisplaySlot")) {
-+                            if (name.startsWith("SIDEBAR_") && !name.startsWith("SIDEBAR_TEAM_")) {
-+                                super.visitFieldInsn(opcode, owner, name.replace("SIDEBAR_", "SIDEBAR_TEAM_"), desc);
-+                                return;
-+                            }
-+                        }
-+                        // Paper end - DisplaySlot
-                         if (owner.equals("org/bukkit/block/Biome")) {
-                             switch (name) {
-                                 case "NETHER":
 diff --git a/src/test/java/io/papermc/paper/scoreboard/DisplaySlotTest.java b/src/test/java/io/papermc/paper/scoreboard/DisplaySlotTest.java
 new file mode 100644
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000

patches/server/Add-more-advancement-API.patch

@@ -167,21 +167,13 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/util/Commodore.java b/src/main
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/util/Commodore.java
 +++ b/src/main/java/org/bukkit/craftbukkit/util/Commodore.java
-@@ -0,0 +0,0 @@ public class Commodore {
-     );
- 
-     // Paper start - Plugin rewrites
-+    private static final String CB_PACKAGE = org.bukkit.Bukkit.getServer().getClass().getPackageName().replace('.', '/');
-     private static final Map<String, String> SEARCH_AND_REMOVE = initReplacementsMap();
-     private static Map<String, String> initReplacementsMap() {
-         Map<String, String> getAndRemove = new HashMap<>();
 @@ -0,0 +0,0 @@ public class Commodore {
                              super.visitMethodInsn(opcode, owner, name, "()Lcom/destroystokyo/paper/profile/PlayerProfile;", itf);
                              return;
                          }
 +                        if (owner.equals("org/bukkit/advancement/Advancement") && name.equals("getDisplay") && desc.endsWith(")Lorg/bukkit/advancement/AdvancementDisplay;")) {
-+                            super.visitTypeInsn(Opcodes.CHECKCAST, CB_PACKAGE + "/advancement/CraftAdvancement");
-+                            super.visitMethodInsn(Opcodes.INVOKEVIRTUAL, CB_PACKAGE + "/advancement/CraftAdvancement", "getDisplay0", desc, false);
++                            super.visitTypeInsn(Opcodes.CHECKCAST, CB_PACKAGE_PREFIX + "advancement/CraftAdvancement");
++                            super.visitMethodInsn(Opcodes.INVOKEVIRTUAL, CB_PACKAGE_PREFIX + "advancement/CraftAdvancement", "getDisplay0", desc, false);
 +                            return;
 +                        }
                          // Paper end

patches/server/Configurable-item-frame-map-cursor-update-interval.patch

@@ -14,6 +14,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 -                if (this.tickCount % 10 == 0 && itemstack.getItem() instanceof MapItem) { // CraftBukkit - Moved this.tickCounter % 10 logic here so item frames do not enter the other blocks
 +                if (this.level.paperConfig().maps.itemFrameCursorUpdateInterval > 0 && this.tickCount % this.level.paperConfig().maps.itemFrameCursorUpdateInterval == 0 && itemstack.getItem() instanceof MapItem) { // CraftBukkit - Moved this.tickCounter % 10 logic here so item frames do not enter the other blocks // Paper - Make item frame map cursor update interval configurable
-                     Integer integer = MapItem.getMapId(itemstack);
-                     MapItemSavedData worldmap = MapItem.getSavedData(integer, this.level);
+                     MapId mapid = (MapId) itemstack.get(DataComponents.MAP_ID);
+                     MapItemSavedData worldmap = MapItem.getSavedData(mapid, this.level);
  

patches/server/Fix-upstreams-block-state-factories.patch

@@ -42,8 +42,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      @Override
--    public CraftBlockEntityState<T> copy() {
--        return new CraftBlockEntityState<>(this);
+-    public CraftBlockEntityState<T> copy(Location location) {
+-        return new CraftBlockEntityState<>(this, location);
 -    }
 +    public abstract CraftBlockEntityState<T> copy(); // Paper - make abstract
  
@@ -271,7 +271,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -        register(Material.DECORATED_POT, CraftDecoratedPot.class, CraftDecoratedPot::new, DecoratedPotBlockEntity::new);
 -        register(Material.DISPENSER, CraftDispenser.class, CraftDispenser::new, DispenserBlockEntity::new);
 -        register(Material.DROPPER, CraftDropper.class, CraftDropper::new, DropperBlockEntity::new);
--        register(Material.ENCHANTING_TABLE, CraftEnchantingTable.class, CraftEnchantingTable::new, EnchantmentTableBlockEntity::new);
+-        register(Material.ENCHANTING_TABLE, CraftEnchantingTable.class, CraftEnchantingTable::new, EnchantingTableBlockEntity::new);
 -        register(Material.ENDER_CHEST, CraftEnderChest.class, CraftEnderChest::new, EnderChestBlockEntity::new);
 -        register(Material.END_GATEWAY, CraftEndGateway.class, CraftEndGateway::new, TheEndGatewayBlockEntity::new);
 -        register(Material.END_PORTAL, CraftEndPortal.class, CraftEndPortal::new, TheEndPortalBlockEntity::new);
@@ -293,6 +293,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -        register(Material.TRAPPED_CHEST, CraftChest.class, CraftChest::new, TrappedChestBlockEntity::new);
 -        register(Material.CRAFTER, CraftCrafter.class, CraftCrafter::new, CrafterBlockEntity::new);
 -        register(Material.TRIAL_SPAWNER, CraftTrialSpawner.class, CraftTrialSpawner::new, TrialSpawnerBlockEntity::new);
+-        register(Material.VAULT, CraftVault.class, CraftVault::new, VaultBlockEntity::new);
 +        // Paper start - simplify
 +        register(BlockEntityType.SIGN, CraftSign.class, CraftSign::new);
 +        register(BlockEntityType.HANGING_SIGN, CraftHangingSign.class, CraftHangingSign::new);
@@ -337,6 +338,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        register(BlockEntityType.TRAPPED_CHEST, CraftChest.class, CraftChest::new);
 +        register(BlockEntityType.CRAFTER, CraftCrafter.class, CraftCrafter::new);
 +        register(BlockEntityType.TRIAL_SPAWNER, CraftTrialSpawner.class, CraftTrialSpawner::new);
++        register(BlockEntityType.VAULT, CraftVault.class, CraftVault::new);
 +        // Paper end
      }
  

patches/server/Goat-ram-API.patch

@@ -9,8 +9,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
 +++ b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
 @@ -0,0 +0,0 @@ public class Goat extends Animal {
-     protected Vector3f getPassengerAttachmentPoint(Entity passenger, EntityDimensions dimensions, float scaleFactor) {
-         return new Vector3f(0.0F, dimensions.height - 0.1875F * scaleFactor, 0.0F);
+     public static boolean checkGoatSpawnRules(EntityType<? extends Animal> entityType, LevelAccessor world, MobSpawnType spawnReason, BlockPos pos, RandomSource random) {
+         return world.getBlockState(pos.below()).is(BlockTags.GOATS_SPAWNABLE_ON) && isBrightEnoughToSpawn(world, pos);
      }
 +
 +    // Paper start - Goat ram API

patches/server/Manually-inline-methods-in-BlockPosition.patch

@@ -60,4 +60,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    protected int z; // Paper - Perf: Manually inline methods in BlockPosition; protected
  
      public static Codec<Vec3i> offsetCodec(int maxAbsValue) {
-         return ExtraCodecs.validate(
+         return CODEC.validate(

patches/server/Oprimise-map-impl-for-tracked-players.patch

@@ -17,5 +17,5 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -        public final Set<ServerPlayerConnection> seenBy = Sets.newIdentityHashSet();
 +        public final Set<ServerPlayerConnection> seenBy = new it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet<>(); // Paper - Perf: optimise map impl
  
-         public TrackedEntity(Entity entity, int i, int j, boolean flag) {
+         public TrackedEntity(final Entity entity, final int i, final int j, final boolean flag) {
              this.serverEntity = new ServerEntity(ChunkMap.this.level, entity, j, flag, this::broadcast, this.seenBy); // CraftBukkit

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

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/jav
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
      }
  
      private Stream<Entity> getIndirectPassengersStream() {
@@ -43,7 +43,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          return () -> {
              return this.getIndirectPassengersStream().iterator();
          };
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
      }
  
      public boolean hasExactlyOnePlayerPassenger() {

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

@@ -25,19 +25,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          this.base = base;
          this.addition = addition;
 @@ -0,0 +0,0 @@ public class SmithingTransformRecipe implements SmithingRecipe {
-     @Override
-     public ItemStack assemble(Container inventory, RegistryAccess registryManager) {
-         ItemStack itemstack = this.result.copy();
+     public ItemStack assemble(Container inventory, HolderLookup.Provider lookup) {
+         ItemStack itemstack = inventory.getItem(1).transmuteCopy(this.result.getItem(), this.result.getCount());
+ 
 +        if (this.copyNBT) { // Paper - Option to prevent NBT copy
-         CompoundTag nbttagcompound = inventory.getItem(1).getTag();
- 
-         if (nbttagcompound != null) {
-             itemstack.setTag(nbttagcompound.copy());
-         }
+         itemstack.applyComponents(this.result.getComponentsPatch());
 +        } // Paper - Option to prevent NBT copy
- 
          return itemstack;
      }
+ 
 @@ -0,0 +0,0 @@ public class SmithingTransformRecipe implements SmithingRecipe {
      public Recipe toBukkitRecipe(NamespacedKey id) {
          CraftItemStack result = CraftItemStack.asCraftMirror(this.result);
@@ -71,11 +67,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      return ItemStack.EMPTY;
                  }
  
--                ItemStack itemstack1 = itemstack.copy();
-+                ItemStack itemstack1 = this.copyNbt ? itemstack.copy() : new ItemStack(itemstack.getItem(), itemstack.getCount()); // Paper - Option to prevent NBT copy
+-                ItemStack itemstack1 = itemstack.copyWithCount(1);
++                ItemStack itemstack1 = this.copyNbt ? itemstack.copyWithCount(1) : new ItemStack(itemstack.getItem(), 1); // Paper - Option to prevent NBT copy
  
-                 itemstack1.setCount(1);
-                 ArmorTrim armortrim = new ArmorTrim((Holder) optional.get(), (Holder) optional1.get());
+                 itemstack1.set(DataComponents.TRIM, new ArmorTrim((Holder) optional.get(), (Holder) optional1.get()));
+                 return itemstack1;
 @@ -0,0 +0,0 @@ public class SmithingTrimRecipe implements SmithingRecipe {
      // CraftBukkit start
      @Override

patches/server/Update-head-rotation-in-missing-places.patch

@@ -11,7 +11,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/jav
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          this.setXRot(Mth.clamp(pitch, -90.0F, 90.0F) % 360.0F);
          this.yRotO = this.getYRot();
          this.xRotO = this.getXRot();
@@ -19,7 +19,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public void absMoveTo(double x, double y, double z) {
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          this.setXRot(pitch);
          this.setOldPosAndRot();
          this.reapplyPosition();

patches/server/prevent-unintended-light-block-manipulation.patch

@@ -10,7 +10,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/world/level/block/LightBlock.java
 @@ -0,0 +0,0 @@ public class LightBlock extends Block implements SimpleWaterloggedBlock {
      @Override
-     public InteractionResult use(BlockState state, Level world, BlockPos pos, Player player, InteractionHand hand, BlockHitResult hit) {
+     protected InteractionResult useWithoutItem(BlockState state, Level world, BlockPos pos, Player player, BlockHitResult hit) {
          if (!world.isClientSide && player.canUseGameMasterBlocks()) {
 +            if (player.getItemInHand(hand).getItem() != Items.LIGHT || !player.mayInteract(world, pos) || !player.mayUseItemAt(pos, hit.getDirection(), player.getItemInHand(hand))) { return InteractionResult.FAIL; } // Paper - Prevent unintended light block manipulation
              world.setBlock(pos, state.cycle(LEVEL), 2);