More entity classes

2024-12-14 12:36:08 +01:00
parent 03daab51f7
commit 07642b457e
11 changed files with 731 additions and 828 deletions
--- a/paper-server/patches/sources/net/minecraft/world/entity/LightningBolt.java.patch
+++ b/paper-server/patches/sources/net/minecraft/world/entity/LightningBolt.java.patch
@@ -0,0 +1,138 @@
+--- a/net/minecraft/world/entity/LightningBolt.java
+++ b/net/minecraft/world/entity/LightningBolt.java
+@@ -39,6 +_,7 @@
+     private ServerPlayer cause;
+     private final Set<Entity> hitEntities = Sets.newHashSet();
+     private int blocksSetOnFire;
+    public boolean isEffect; // Paper - Properly handle lightning effects api
+ 
+     public LightningBolt(EntityType<? extends LightningBolt> entityType, Level level) {
+         super(entityType, level);
+@@ -76,7 +_,7 @@
+     @Override
+     public void tick() {
+         super.tick();
+-        if (this.life == 2) {
+        if (!this.isEffect && this.life == 2) { // Paper - Properly handle lightning effects api
+             if (this.level().isClientSide()) {
+                 this.level()
+                     .playLocalSound(
+@@ -107,7 +_,7 @@
+                 }
+ 
+                 this.powerLightningRod();
+-                clearCopperOnLightningStrike(this.level(), this.getStrikePosition());
+                clearCopperOnLightningStrike(this.level(), this.getStrikePosition(), this); // Paper - Call EntityChangeBlockEvent
+                 this.gameEvent(GameEvent.LIGHTNING_STRIKE);
+             }
+         }
+@@ -130,7 +_,7 @@
+                     }
+                 }
+ 
+-                this.discard();
+                this.discard(org.bukkit.event.entity.EntityRemoveEvent.Cause.DESPAWN); // CraftBukkit - add Bukkit remove cause
+             } else if (this.life < -this.random.nextInt(10)) {
+                 this.flashes--;
+                 this.life = 1;
+@@ -139,10 +_,10 @@
+             }
+         }
+ 
+-        if (this.life >= 0) {
+        if (this.life >= 0 && !this.isEffect) { // CraftBukkit - add !this.visualOnly // Paper - Properly handle lightning effects api
+             if (!(this.level() instanceof ServerLevel)) {
+                 this.level().setSkyFlashTime(2);
+-            } else if (!this.visualOnly) {
+            } else if (!this.visualOnly && !this.isEffect) {  // Paper - Properly handle lightning effects api
+                 List<Entity> entities = this.level()
+                     .getEntities(
+                         this,
+@@ -172,22 +_,30 @@
+             BlockPos blockPos = this.blockPosition();
+             BlockState state = BaseFireBlock.getState(this.level(), blockPos);
+             if (this.level().getBlockState(blockPos).isAir() && state.canSurvive(this.level(), blockPos)) {
+-                this.level().setBlockAndUpdate(blockPos, state);
+-                this.blocksSetOnFire++;
+                // CraftBukkit start - add "!visualOnly"
+                if (!this.visualOnly && !org.bukkit.craftbukkit.event.CraftEventFactory.callBlockIgniteEvent(this.level(), blockPos, this).isCancelled()) {
+                    this.level().setBlockAndUpdate(blockPos, state);
+                    this.blocksSetOnFire++;
+                }
+                // CraftBukkit end
+             }
+ 
+             for (int i = 0; i < extraIgnitions; i++) {
+                 BlockPos blockPos1 = blockPos.offset(this.random.nextInt(3) - 1, this.random.nextInt(3) - 1, this.random.nextInt(3) - 1);
+                 state = BaseFireBlock.getState(this.level(), blockPos1);
+                 if (this.level().getBlockState(blockPos1).isAir() && state.canSurvive(this.level(), blockPos1)) {
+-                    this.level().setBlockAndUpdate(blockPos1, state);
+-                    this.blocksSetOnFire++;
+                    // CraftBukkit start - add "!visualOnly"
+                    if (!this.visualOnly && !org.bukkit.craftbukkit.event.CraftEventFactory.callBlockIgniteEvent(this.level(), blockPos1, this).isCancelled()) {
+                        this.level().setBlockAndUpdate(blockPos1, state);
+                        this.blocksSetOnFire++;
+                    }
+                    // CraftBukkit end
+                 }
+             }
+         }
+     }
+ 
+-    private static void clearCopperOnLightningStrike(Level level, BlockPos pos) {
+    private static void clearCopperOnLightningStrike(Level level, BlockPos pos, Entity lightning) { // Paper - Call EntityChangeBlockEvent
+         BlockState blockState = level.getBlockState(pos);
+         BlockPos blockPos;
+         BlockState blockState1;
+@@ -200,22 +_,27 @@
+         }
+ 
+         if (blockState1.getBlock() instanceof WeatheringCopper) {
+-            level.setBlockAndUpdate(blockPos, WeatheringCopper.getFirst(level.getBlockState(blockPos)));
+            // Paper start - Call EntityChangeBlockEvent
+            BlockState newBlockState = WeatheringCopper.getFirst(level.getBlockState(blockPos));
+            if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(lightning, blockPos, newBlockState)) {
+                level.setBlockAndUpdate(blockPos, newBlockState);
+            }
+            // Paper end - Call EntityChangeBlockEvent
+             BlockPos.MutableBlockPos mutableBlockPos = pos.mutable();
+             int i = level.random.nextInt(3) + 3;
+ 
+             for (int i1 = 0; i1 < i; i1++) {
+                 int i2 = level.random.nextInt(8) + 1;
+-                randomWalkCleaningCopper(level, blockPos, mutableBlockPos, i2);
+                randomWalkCleaningCopper(level, blockPos, mutableBlockPos, i2, lightning); // Paper - transmit LightningBolt instance to call EntityChangeBlockEvent
+             }
+         }
+     }
+ 
+-    private static void randomWalkCleaningCopper(Level level, BlockPos pos, BlockPos.MutableBlockPos mutable, int steps) {
+    private static void randomWalkCleaningCopper(Level level, BlockPos pos, BlockPos.MutableBlockPos mutable, int steps, Entity lightning) { // Paper - transmit LightningBolt instance to call EntityChangeBlockEvent
+         mutable.set(pos);
+ 
+         for (int i = 0; i < steps; i++) {
+-            Optional<BlockPos> optional = randomStepCleaningCopper(level, mutable);
+            Optional<BlockPos> optional = randomStepCleaningCopper(level, mutable, lightning); // Paper - transmit LightningBolt instance to call EntityChangeBlockEvent
+             if (optional.isEmpty()) {
+                 break;
+             }
+@@ -224,11 +_,17 @@
+         }
+     }
+ 
+-    private static Optional<BlockPos> randomStepCleaningCopper(Level level, BlockPos pos) {
+    private static Optional<BlockPos> randomStepCleaningCopper(Level level, BlockPos pos, Entity lightning) { // Paper - transmit LightningBolt instance to call EntityChangeBlockEvent
+         for (BlockPos blockPos : BlockPos.randomInCube(level.random, 10, pos, 1)) {
+             BlockState blockState = level.getBlockState(blockPos);
+             if (blockState.getBlock() instanceof WeatheringCopper) {
+-                WeatheringCopper.getPrevious(blockState).ifPresent(blockState1 -> level.setBlockAndUpdate(blockPos, blockState1));
+                // Paper start - call EntityChangeBlockEvent
+                WeatheringCopper.getPrevious(blockState).ifPresent(blockState1 -> {
+                    if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(lightning, blockPos, blockState1)) {
+                        level.setBlockAndUpdate(blockPos, blockState1);
+                    }
+                });
+                // Paper end - call EntityChangeBlockEvent
+                 level.levelEvent(3002, blockPos, -1);
+                 return Optional.of(blockPos);
+             }
--- a/paper-server/patches/sources/net/minecraft/world/entity/Mob.java.patch
+++ b/paper-server/patches/sources/net/minecraft/world/entity/Mob.java.patch
@@ -0,0 +1,428 @@
+--- a/net/minecraft/world/entity/Mob.java
+++ b/net/minecraft/world/entity/Mob.java
+@@ -84,6 +_,18 @@
+ import net.minecraft.world.level.storage.loot.parameters.LootContextParams;
+ import net.minecraft.world.phys.AABB;
+ 
+// CraftBukkit start
+import org.bukkit.craftbukkit.event.CraftEventFactory;
+import org.bukkit.craftbukkit.entity.CraftLivingEntity;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.event.entity.EntityRemoveEvent;
+import org.bukkit.event.entity.EntityTargetLivingEntityEvent;
+import org.bukkit.event.entity.EntityTargetEvent;
+import org.bukkit.event.entity.EntityTransformEvent;
+import org.bukkit.event.entity.EntityUnleashEvent;
+import org.bukkit.event.entity.EntityUnleashEvent.UnleashReason;
+// CraftBukkit end
+
+ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashable, Targeting {
+     private static final EntityDataAccessor<Byte> DATA_MOB_FLAGS_ID = SynchedEntityData.defineId(Mob.class, EntityDataSerializers.BYTE);
+     private static final int MOB_FLAG_NO_AI = 1;
+@@ -112,6 +_,7 @@
+     private final BodyRotationControl bodyRotationControl;
+     protected PathNavigation navigation;
+     public GoalSelector goalSelector;
+    @Nullable public net.minecraft.world.entity.ai.goal.FloatGoal goalFloat; // Paper - Allow nerfed mobs to jump and float
+     public GoalSelector targetSelector;
+     @Nullable
+     private LivingEntity target;
+@@ -131,6 +_,7 @@
+     private Leashable.LeashData leashData;
+     private BlockPos restrictCenter = BlockPos.ZERO;
+     private float restrictRadius = -1.0F;
+    public boolean aware = true; // CraftBukkit
+ 
+     protected Mob(EntityType<? extends Mob> entityType, Level level) {
+         super(entityType, level);
+@@ -150,6 +_,12 @@
+         }
+     }
+ 
+    // CraftBukkit start
+    public void setPersistenceRequired(boolean persistenceRequired) {
+        this.persistenceRequired = persistenceRequired;
+    }
+    // CraftBukkit end
+
+     protected void registerGoals() {
+     }
+ 
+@@ -230,7 +_,40 @@
+     }
+ 
+     public void setTarget(@Nullable LivingEntity target) {
+        // CraftBukkit start - fire event
+        this.setTarget(target, EntityTargetEvent.TargetReason.UNKNOWN, true);
+    }
+
+    public boolean setTarget(LivingEntity target, EntityTargetEvent.TargetReason reason, boolean fireEvent) {
+        if (this.getTarget() == target) {
+            return false;
+        }
+        if (fireEvent) {
+            if (reason == EntityTargetEvent.TargetReason.UNKNOWN && this.getTarget() != null && target == null) {
+                reason = this.getTarget().isAlive() ? EntityTargetEvent.TargetReason.FORGOT_TARGET : EntityTargetEvent.TargetReason.TARGET_DIED;
+            }
+            if (reason == EntityTargetEvent.TargetReason.UNKNOWN) {
+                this.level().getCraftServer().getLogger().log(java.util.logging.Level.WARNING, "Unknown target reason, please report on the issue tracker", new Exception());
+            }
+            CraftLivingEntity ctarget = null;
+            if (target != null) {
+                ctarget = (CraftLivingEntity) target.getBukkitEntity();
+            }
+            EntityTargetLivingEntityEvent event = new EntityTargetLivingEntityEvent(this.getBukkitEntity(), ctarget, reason);
+            this.level().getCraftServer().getPluginManager().callEvent(event);
+            if (event.isCancelled()) {
+                return false;
+            }
+
+            if (event.getTarget() != null) {
+                target = ((CraftLivingEntity) event.getTarget()).getHandle();
+            } else {
+                target = null;
+            }
+        }
+         this.target = target;
+        return true;
+        // CraftBukkit end
+     }
+ 
+     @Override
+@@ -354,6 +_,12 @@
+         return null;
+     }
+ 
+    // CraftBukkit start - Add delegate method
+    public SoundEvent getAmbientSound0() {
+        return this.getAmbientSound();
+    }
+    // CraftBukkit end
+
+     @Override
+     public void addAdditionalSaveData(CompoundTag compound) {
+         super.addAdditionalSaveData(compound);
+@@ -413,13 +_,25 @@
+         if (this.isNoAi()) {
+             compound.putBoolean("NoAI", this.isNoAi());
+         }
+        compound.putBoolean("Bukkit.Aware", this.aware); // CraftBukkit
+     }
+ 
+     @Override
+     public void readAdditionalSaveData(CompoundTag compound) {
+         super.readAdditionalSaveData(compound);
+-        this.setCanPickUpLoot(compound.getBoolean("CanPickUpLoot"));
+-        this.persistenceRequired = compound.getBoolean("PersistenceRequired");
+        // CraftBukkit start - If looting or persistence is false only use it if it was set after we started using it
+        if (compound.contains("CanPickUpLoot", 99)) {
+            boolean data = compound.getBoolean("CanPickUpLoot");
+            if (isLevelAtLeast(compound, 1) || data) {
+                this.setCanPickUpLoot(data);
+            }
+        }
+
+        boolean data = compound.getBoolean("PersistenceRequired");
+        if (isLevelAtLeast(compound, 1) || data) {
+            this.persistenceRequired = data;
+        }
+        // CraftBukkit end
+         if (compound.contains("ArmorItems", 9)) {
+             ListTag list = compound.getList("ArmorItems", 10);
+ 
+@@ -472,13 +_,18 @@
+         this.readLeashData(compound);
+         this.setLeftHanded(compound.getBoolean("LeftHanded"));
+         if (compound.contains("DeathLootTable", 8)) {
+-            this.lootTable = Optional.of(ResourceKey.create(Registries.LOOT_TABLE, ResourceLocation.parse(compound.getString("DeathLootTable"))));
+            this.lootTable = Optional.ofNullable(ResourceLocation.tryParse(compound.getString("DeathLootTable"))).map((rs) -> ResourceKey.create(Registries.LOOT_TABLE, rs)); // Paper - Validate ResourceLocation
+         } else {
+             this.lootTable = Optional.empty();
+         }
+ 
+         this.lootTableSeed = compound.getLong("DeathLootTableSeed");
+         this.setNoAi(compound.getBoolean("NoAI"));
+        // CraftBukkit start
+        if (compound.contains("Bukkit.Aware")) {
+            this.aware = compound.getBoolean("Bukkit.Aware");
+        }
+        // CraftBukkit end
+     }
+ 
+     @Override
+@@ -540,6 +_,11 @@
+                     && !itemEntity.getItem().isEmpty()
+                     && !itemEntity.hasPickUpDelay()
+                     && this.wantsToPickUp(serverLevel, itemEntity.getItem())) {
+                    // Paper start - Item#canEntityPickup
+                    if (!itemEntity.canMobPickup) {
+                        continue;
+                    }
+                    // Paper end - Item#canEntityPickup
+                     this.pickUpItem(serverLevel, itemEntity);
+                 }
+             }
+@@ -554,18 +_,24 @@
+ 
+     protected void pickUpItem(ServerLevel level, ItemEntity entity) {
+         ItemStack item = entity.getItem();
+-        ItemStack itemStack = this.equipItemIfPossible(level, item.copy());
+        ItemStack itemStack = this.equipItemIfPossible(level, item.copy(), entity); // CraftBukkit - add item
+         if (!itemStack.isEmpty()) {
+             this.onItemPickup(entity);
+             this.take(entity, itemStack.getCount());
+             item.shrink(itemStack.getCount());
+             if (item.isEmpty()) {
+-                entity.discard();
+                entity.discard(EntityRemoveEvent.Cause.PICKUP); // CraftBukkit - add Bukkit remove cause
+             }
+         }
+     }
+ 
+     public ItemStack equipItemIfPossible(ServerLevel level, ItemStack stack) {
+        // CraftBukkit start - add item
+        return this.equipItemIfPossible(level, stack, null);
+    }
+
+    public ItemStack equipItemIfPossible(ServerLevel level, ItemStack stack, ItemEntity entity) {
+        // CraftBukkit end
+         EquipmentSlot equipmentSlotForItem = this.getEquipmentSlotForItem(stack);
+         ItemStack itemBySlot = this.getItemBySlot(equipmentSlotForItem);
+         boolean canReplaceCurrentItem = this.canReplaceCurrentItem(stack, itemBySlot, equipmentSlotForItem);
+@@ -575,10 +_,18 @@
+             canReplaceCurrentItem = itemBySlot.isEmpty();
+         }
+ 
+-        if (canReplaceCurrentItem && this.canHoldItem(stack)) {
+        // CraftBukkit start
+        boolean canPickup = canReplaceCurrentItem && this.canHoldItem(stack);
+        if (entity != null) {
+            canPickup = !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityPickupItemEvent(this, entity, 0, !canPickup).isCancelled();
+        }
+        if (canPickup) {
+            // CraftBukkit end
+             double d = this.getEquipmentDropChance(equipmentSlotForItem);
+             if (!itemBySlot.isEmpty() && Math.max(this.random.nextFloat() - 0.1F, 0.0F) < d) {
+                this.forceDrops = true; // CraftBukkit
+                 this.spawnAtLocation(level, itemBySlot);
+                this.forceDrops = false; // CraftBukkit
+             }
+ 
+             ItemStack itemStack = equipmentSlotForItem.limit(stack);
+@@ -703,22 +_,29 @@
+     @Override
+     public void checkDespawn() {
+         if (this.level().getDifficulty() == Difficulty.PEACEFUL && this.shouldDespawnInPeaceful()) {
+-            this.discard();
+            this.discard(EntityRemoveEvent.Cause.DESPAWN); // CraftBukkit - add Bukkit remove cause
+         } else if (!this.isPersistenceRequired() && !this.requiresCustomPersistence()) {
+-            Entity nearestPlayer = this.level().getNearestPlayer(this, -1.0);
+            Entity nearestPlayer = this.level().getNearestPlayer(this, -1.0, EntitySelector.PLAYER_AFFECTS_SPAWNING); // Paper - Affects Spawning API
+             if (nearestPlayer != null) {
+-                double d = nearestPlayer.distanceToSqr(this);
+-                int despawnDistance = this.getType().getCategory().getDespawnDistance();
+-                int i = despawnDistance * despawnDistance;
+-                if (d > i && this.removeWhenFarAway(d)) {
+-                    this.discard();
+-                }
+                // Paper start - Configurable despawn distances
+                final io.papermc.paper.configuration.WorldConfiguration.Entities.Spawning.DespawnRangePair despawnRangePair = this.level().paperConfig().entities.spawning.despawnRanges.get(this.getType().getCategory());
+                final io.papermc.paper.configuration.type.DespawnRange.Shape shape = this.level().paperConfig().entities.spawning.despawnRangeShape;
+                final double dy = Math.abs(nearestPlayer.getY() - this.getY());
+                final double dySqr = Math.pow(dy, 2);
+                final double dxSqr = Math.pow(nearestPlayer.getX() - this.getX(), 2);
+                final double dzSqr = Math.pow(nearestPlayer.getZ() - this.getZ(), 2);
+                final double distanceSquared = dxSqr + dzSqr + dySqr;
+                // Despawn if hard/soft limit is exceeded
+                if (despawnRangePair.hard().shouldDespawn(shape, dxSqr, dySqr, dzSqr, dy) && this.removeWhenFarAway(distanceSquared)) {
+                    this.discard(EntityRemoveEvent.Cause.DESPAWN); // CraftBukkit - add Bukkit remove cause
+                 }
+ 
+-                int noDespawnDistance = this.getType().getCategory().getNoDespawnDistance();
+-                int i1 = noDespawnDistance * noDespawnDistance;
+-                if (this.noActionTime > 600 && this.random.nextInt(800) == 0 && d > i1 && this.removeWhenFarAway(d)) {
+-                    this.discard();
+-                } else if (d < i1) {
+                if (despawnRangePair.soft().shouldDespawn(shape, dxSqr, dySqr, dzSqr, dy)) {
+                    if (this.noActionTime > 600 && this.random.nextInt(800) == 0 && this.removeWhenFarAway(distanceSquared)) {
+                        this.discard(EntityRemoveEvent.Cause.DESPAWN); // CraftBukkit - add Bukkit remove cause
+                    }
+                } else {
+                    // Paper end - Configurable despawn distances
+                     this.noActionTime = 0;
+                 }
+             }
+@@ -730,6 +_,15 @@
+     @Override
+     protected final void serverAiStep() {
+         this.noActionTime++;
+        // Paper start - Allow nerfed mobs to jump and float
+        if (!this.aware) {
+            if (goalFloat != null) {
+                if (goalFloat.canUse()) goalFloat.tick();
+                this.getJumpControl().tick();
+            }
+            return;
+        }
+        // Paper end - Allow nerfed mobs to jump and float
+         ProfilerFiller profilerFiller = Profiler.get();
+         profilerFiller.push("sensing");
+         this.sensing.tick();
+@@ -908,26 +_,40 @@
+ 
+     @Override
+     public void setItemSlot(EquipmentSlot slot, ItemStack stack) {
+        // Paper start - Fix silent equipment change
+        setItemSlot(slot, stack, false);
+    }
+
+    @Override
+    public void setItemSlot(EquipmentSlot slot, ItemStack stack, boolean silent) {
+        // Paper end - Fix silent equipment change
+         this.verifyEquippedItem(stack);
+         switch (slot.getType()) {
+             case HAND:
+-                this.onEquipItem(slot, this.handItems.set(slot.getIndex(), stack), stack);
+                this.onEquipItem(slot, this.handItems.set(slot.getIndex(), stack), stack, silent); // Paper - Fix silent equipment change
+                 break;
+             case HUMANOID_ARMOR:
+-                this.onEquipItem(slot, this.armorItems.set(slot.getIndex(), stack), stack);
+                this.onEquipItem(slot, this.armorItems.set(slot.getIndex(), stack), stack, silent); // Paper - Fix silent equipment change
+                 break;
+             case ANIMAL_ARMOR:
+                 ItemStack itemStack = this.bodyArmorItem;
+                 this.bodyArmorItem = stack;
+-                this.onEquipItem(slot, itemStack, stack);
+                this.onEquipItem(slot, itemStack, stack, silent); // Paper - Fix silent equipment change
+         }
+     }
+
+    // Paper start
+    protected boolean shouldSkipLoot(EquipmentSlot slot) { // method to avoid to fallback into the global mob loot logic (i.e fox)
+        return false;
+    }
+    // Paper end
+ 
+     @Override
+     protected void dropCustomDeathLoot(ServerLevel level, DamageSource damageSource, boolean recentlyHit) {
+         super.dropCustomDeathLoot(level, damageSource, recentlyHit);
+ 
+         for (EquipmentSlot equipmentSlot : EquipmentSlot.VALUES) {
+            if (this.shouldSkipLoot(equipmentSlot)) continue; // Paper
+             ItemStack itemBySlot = this.getItemBySlot(equipmentSlot);
+             float equipmentDropChance = this.getEquipmentDropChance(equipmentSlot);
+             if (equipmentDropChance != 0.0F) {
+@@ -951,7 +_,13 @@
+                     }
+ 
+                     this.spawnAtLocation(level, itemBySlot);
+                    if (this.clearEquipmentSlots) { // Paper
+                     this.setItemSlot(equipmentSlot, ItemStack.EMPTY);
+                    // Paper start
+                    } else {
+                        this.clearedEquipmentSlots.add(enumitemslot);
+                    }
+                    // Paper end
+                 }
+             }
+         }
+@@ -1269,6 +_,22 @@
+     public <T extends Mob> T convertTo(
+         EntityType<T> entityType, ConversionParams conversionParams, EntitySpawnReason spawnReason, ConversionParams.AfterConversion<T> afterConversion
+     ) {
+        return this.convertTo(entityType, conversionParams, spawnReason, afterConversion, EntityTransformEvent.TransformReason.UNKNOWN, CreatureSpawnEvent.SpawnReason.DEFAULT);
+    }
+
+    @Nullable
+    public <T extends Mob> T convertTo(
+        EntityType<T> entityType, ConversionParams conversionParams, EntitySpawnReason spawnReason, ConversionParams.AfterConversion<T> afterConversion, EntityTransformEvent.TransformReason transformReason, CreatureSpawnEvent.SpawnReason creatureSpawnReason
+    ) {
+    // Paper start - entity zap event - allow cancellation of conversion post creation
+        return this.convertTo(entityType, conversionParams, spawnReason, e -> { afterConversion.finalizeConversion(e); return true; }, transformReason, spawnReason);
+    }
+    @Nullable
+    public <T extends Mob> T convertTo(
+        EntityType<T> entityType, ConversionParams conversionParams, EntitySpawnReason spawnReason, ConversionParams.CancellingAfterConversion<T> afterConversion, EntityTransformEvent.TransformReason transformReason, CreatureSpawnEvent.SpawnReason creatureSpawnReason
+    ) {
+        // Paper end - entity zap event - allow cancellation of conversion post creation
+        // CraftBukkit end
+         if (this.isRemoved()) {
+             return null;
+         } else {
+@@ -1277,13 +_,23 @@
+                 return null;
+             } else {
+                 conversionParams.type().convert(this, mob, conversionParams);
+-                afterConversion.finalizeConversion(mob);
+                if (!afterConversion.finalizeConversionOrCancel(mob)) return null; // Paper - entity zap event - return null if conversion was cancelled
+                // CraftBukkit start
+                if (transformReason == null) {
+                    // Special handling for slime split and pig lightning
+                    return mob;
+                }
+
+                if (CraftEventFactory.callEntityTransformEvent(this, mob, transformReason).isCancelled()) {
+                    return null;
+                }
+                // CraftBukkit end
+                 if (this.level() instanceof ServerLevel serverLevel) {
+-                    serverLevel.addFreshEntity(mob);
+                    serverLevel.addFreshEntity(mob, creatureSpawnReason); // CraftBukkit
+                 }
+ 
+                 if (conversionParams.type().shouldDiscardAfterConversion()) {
+-                    this.discard();
+                    this.discard(EntityRemoveEvent.Cause.TRANSFORMATION); // CraftBukkit - add Bukkit remove cause
+                 }
+ 
+                 return mob;
+@@ -1293,7 +_,20 @@
+ 
+     @Nullable
+     public <T extends Mob> T convertTo(EntityType<T> entityType, ConversionParams coversionParams, ConversionParams.AfterConversion<T> afterConversion) {
+-        return this.convertTo(entityType, coversionParams, EntitySpawnReason.CONVERSION, afterConversion);
+        // CraftBukkit start
+        return this.convertTo(entityType, coversionParams, afterConversion, EntityTransformEvent.TransformReason.UNKNOWN, CreatureSpawnEvent.SpawnReason.DEFAULT);
+    }
+
+    @Nullable
+    public <T extends Mob> T convertTo(EntityType<T> entityType, ConversionParams coversionParams, ConversionParams.AfterConversion<T> afterConversion, EntityTransformEvent.TransformReason transformReason, CreatureSpawnEvent.SpawnReason creatureSpawnReason) {
+    // Paper start - entity zap event - allow cancellation of conversion post creation
+        return this.convertTo(entityType, coversionParams, e -> { afterConversion.finalizeConversion(e); return true; }, transformReason, creatureSpawnReason);
+    }
+    @Nullable
+    public <T extends Mob> T convertTo(EntityType<T> entityType, ConversionParams coversionParams, ConversionParams.CancellingAfterConversion<T> afterConversion, EntityTransformEvent.TransformReason transformReason, CreatureSpawnEvent.SpawnReason creatureSpawnReason) {
+    // Paper start - entity zap event - allow cancellation of conversion post creation
+        return this.convertTo(entityType, coversionParams, EntitySpawnReason.CONVERSION, afterConversion, transformReason, creatureSpawnReason);
+        // CraftBukkit end
+     }
+ 
+     @Nullable
+@@ -1329,7 +_,17 @@
+     public boolean startRiding(Entity entity, boolean force) {
+         boolean flag = super.startRiding(entity, force);
+         if (flag && this.isLeashed()) {
+-            this.dropLeash();
+            // Paper start - Expand EntityUnleashEvent
+            EntityUnleashEvent event = new EntityUnleashEvent(this.getBukkitEntity(), EntityUnleashEvent.UnleashReason.UNKNOWN, true);
+            if (!event.callEvent()) {
+                return flag;
+            }
+            if (event.isDropLeash()) {
+                this.dropLeash();
+            } else {
+                this.removeLeash();
+            }
+            // Paper end - Expand EntityUnleashEvent
+         }
+ 
+         return flag;
+@@ -1412,7 +_,7 @@
+             float knockback = this.getKnockback(source, damageSource);
+             if (knockback > 0.0F && source instanceof LivingEntity livingEntity) {
+                 livingEntity.knockback(
+-                    knockback * 0.5F, Mth.sin(this.getYRot() * (float) (Math.PI / 180.0)), -Mth.cos(this.getYRot() * (float) (Math.PI / 180.0))
+                    knockback * 0.5F, Mth.sin(this.getYRot() * (float) (Math.PI / 180.0)), -Mth.cos(this.getYRot() * (float) (Math.PI / 180.0)), this, io.papermc.paper.event.entity.EntityKnockbackEvent.Cause.ENTITY_ATTACK // CraftBukkit // Paper - knockback events
+                 );
+                 this.setDeltaMovement(this.getDeltaMovement().multiply(0.6, 1.0, 0.6));
+             }
--- a/paper-server/patches/sources/net/minecraft/world/entity/NeutralMob.java.patch
+++ b/paper-server/patches/sources/net/minecraft/world/entity/NeutralMob.java.patch
@@ -0,0 +1,69 @@
+--- a/net/minecraft/world/entity/NeutralMob.java
+++ b/net/minecraft/world/entity/NeutralMob.java
+@@ -39,18 +_,11 @@
+             } else {
+                 UUID uuid = tag.getUUID("AngryAt");
+                 this.setPersistentAngerTarget(uuid);
+-                Entity entity = ((ServerLevel)level).getEntity(uuid);
+-                if (entity != null) {
+-                    if (entity instanceof Mob mob) {
+-                        this.setTarget(mob);
+-                        this.setLastHurtByMob(mob);
+-                    }
+-
+-                    if (entity instanceof Player player) {
+-                        this.setTarget(player);
+-                        this.setLastHurtByPlayer(player);
+-                    }
+-                }
+                // Paper - Prevent entity loading causing async lookups; Moved diff to separate method
+                // If this entity already survived its first tick, e.g. is loaded and ticked in sync, actively
+                // tick the initial persistent anger.
+                // If not, let the first tick on the baseTick call the method later down the line.
+                if (this instanceof Entity entity && !entity.firstTick) this.tickInitialPersistentAnger(level);
+             }
+         }
+     }
+@@ -104,7 +_,7 @@
+     default void stopBeingAngry() {
+         this.setLastHurtByMob(null);
+         this.setPersistentAngerTarget(null);
+-        this.setTarget(null);
+        this.setTarget(null, org.bukkit.event.entity.EntityTargetEvent.TargetReason.FORGOT_TARGET, true); // CraftBukkit
+         this.setRemainingPersistentAngerTime(0);
+     }
+ 
+@@ -117,8 +_,33 @@
+ 
+     void setTarget(@Nullable LivingEntity livingEntity);
+ 
+    boolean setTarget(@Nullable LivingEntity entityliving, org.bukkit.event.entity.EntityTargetEvent.TargetReason reason, boolean fireEvent); // CraftBukkit
+
+     boolean canAttack(LivingEntity entity);
+ 
+     @Nullable
+     LivingEntity getTarget();
+
+    // Paper start - Prevent entity loading causing async lookups
+    // Update last hurt when ticking
+    default void tickInitialPersistentAnger(Level level) {
+        UUID uuid = getPersistentAngerTarget();
+        if (uuid == null) {
+            return;
+        }
+
+        Entity entity = ((ServerLevel)level).getEntity(uuid);
+        if (entity != null) {
+            if (entity instanceof Mob mob) {
+                this.setTarget(mob, org.bukkit.event.entity.EntityTargetEvent.TargetReason.UNKNOWN, false); // CraftBukkit
+                this.setLastHurtByMob(mob);
+            }
+
+            if (entity instanceof Player player) {
+                this.setTarget(player, org.bukkit.event.entity.EntityTargetEvent.TargetReason.UNKNOWN, false); // CraftBukkit
+                this.setLastHurtByPlayer(player);
+            }
+        }
+    }
+    // Paper end - Prevent entity loading causing async lookups
+ }
--- a/paper-server/patches/sources/net/minecraft/world/entity/OminousItemSpawner.java.patch
+++ b/paper-server/patches/sources/net/minecraft/world/entity/OminousItemSpawner.java.patch
@@ -0,0 +1,29 @@
+--- a/net/minecraft/world/entity/OminousItemSpawner.java
+++ b/net/minecraft/world/entity/OminousItemSpawner.java
+@@ -76,7 +_,7 @@
+                     entity = this.spawnProjectile(serverLevel, projectileItem, item);
+                 } else {
+                     entity = new ItemEntity(serverLevel, this.getX(), this.getY(), this.getZ(), item);
+-                    serverLevel.addFreshEntity(entity);
+                    serverLevel.addFreshEntity(entity, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.OMINOUS_ITEM_SPAWNER); // Paper - fixes and addition to spawn reason API
+                 }
+ 
+                 serverLevel.levelEvent(3021, this.blockPosition(), 1);
+@@ -90,7 +_,7 @@
+         ProjectileItem.DispenseConfig dispenseConfig = projectileItem.createDispenseConfig();
+         dispenseConfig.overrideDispenseEvent().ifPresent(i -> level.levelEvent(i, this.blockPosition(), 0));
+         Direction direction = Direction.DOWN;
+-        Projectile projectile = Projectile.spawnProjectileUsingShoot(
+        Projectile projectile = Projectile.spawnProjectileUsingShootDelayed( // Paper - fixes and addition to spawn reason API
+             projectileItem.asProjectile(level, this.position(), stack, direction),
+             level,
+             stack,
+@@ -99,7 +_,7 @@
+             direction.getStepZ(),
+             dispenseConfig.power(),
+             dispenseConfig.uncertainty()
+-        );
+        ).spawn(org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.OMINOUS_ITEM_SPAWNER); // Paper - fixes and addition to spawn reason API
+         projectile.setOwner(this);
+         return projectile;
+     }
--- a/paper-server/patches/sources/net/minecraft/world/entity/Shearable.java.patch
+++ b/paper-server/patches/sources/net/minecraft/world/entity/Shearable.java.patch
@@ -0,0 +1,19 @@
+--- a/net/minecraft/world/entity/Shearable.java
+++ b/net/minecraft/world/entity/Shearable.java
+@@ -5,7 +_,16 @@
+ import net.minecraft.world.item.ItemStack;
+ 
+ public interface Shearable {
+    default void shear(ServerLevel level, SoundSource soundSource, ItemStack shears, java.util.List<net.minecraft.world.item.ItemStack> drops) { this.shear(level, soundSource, shears); } // Paper - Add drops to shear events
+     void shear(ServerLevel level, SoundSource soundSource, ItemStack shears);
+ 
+     boolean readyForShearing();
+
+    net.minecraft.world.level.Level level(); // Shearable API - expose default level needed for shearing.
+
+    // Paper start - custom shear drops; ensure all implementing entities override this
+    default java.util.List<net.minecraft.world.item.ItemStack> generateDefaultDrops(final ServerLevel serverLevel, final ItemStack shears) {
+        return java.util.Collections.emptyList();
+    }
+    // Paper end - custom shear drops
+ }
--- a/paper-server/patches/sources/net/minecraft/world/entity/TamableAnimal.java.patch
+++ b/paper-server/patches/sources/net/minecraft/world/entity/TamableAnimal.java.patch
@@ -0,0 +1,82 @@
+--- a/net/minecraft/world/entity/TamableAnimal.java
+++ b/net/minecraft/world/entity/TamableAnimal.java
+@@ -57,7 +_,7 @@
+             compound.putUUID("Owner", this.getOwnerUUID());
+         }
+ 
+-        compound.putBoolean("Sitting", this.orderedToSit);
+        compound.putBoolean("Sitting", this.orderedToSit);f
+     }
+ 
+     @Override
+@@ -84,7 +_,7 @@
+         }
+ 
+         this.orderedToSit = compound.getBoolean("Sitting");
+-        this.setInSittingPose(this.orderedToSit);
+        this.setInSittingPose(this.orderedToSit, false); // Paper - Add EntityToggleSitEvent
+     }
+ 
+     @Override
+@@ -95,8 +_,16 @@
+     @Override
+     public boolean handleLeashAtDistance(Entity leashHolder, float distance) {
+         if (this.isInSittingPose()) {
+-            if (distance > 10.0F) {
+-                this.dropLeash();
+            if (distance > (float) this.level().paperConfig().misc.maxLeashDistance.or(Leashable.LEASH_TOO_FAR_DIST)) { // Paper - Configurable max leash distance
+                // Paper start - Expand EntityUnleashEvent
+                org.bukkit.event.entity.EntityUnleashEvent event = new org.bukkit.event.entity.EntityUnleashEvent(this.getBukkitEntity(), org.bukkit.event.entity.EntityUnleashEvent.UnleashReason.DISTANCE, true);
+                if (!event.callEvent()) return false;
+                if (event.isDropLeash()) {
+                    this.dropLeash();
+                } else {
+                    this.removeLeash();
+                }
+                // Paper end - Expand EntityUnleashEvent
+             }
+ 
+             return false;
+@@ -155,6 +_,12 @@
+     }
+ 
+     public void setInSittingPose(boolean sitting) {
+        // Paper start - Add EntityToggleSitEvent
+        this.setInSittingPose(sitting, true);
+    }
+    public void setInSittingPose(boolean sitting, boolean callEvent) {
+        if (callEvent && !new io.papermc.paper.event.entity.EntityToggleSitEvent(this.getBukkitEntity(), sitting).callEvent()) return;
+        // Paper end - Add EntityToggleSitEvent
+         byte b = this.entityData.get(DATA_FLAGS_ID);
+         if (sitting) {
+             this.entityData.set(DATA_FLAGS_ID, (byte)(b | 1));
+@@ -227,7 +_,12 @@
+         if (this.level() instanceof ServerLevel serverLevel
+             && serverLevel.getGameRules().getBoolean(GameRules.RULE_SHOWDEATHMESSAGES)
+             && this.getOwner() instanceof ServerPlayer serverPlayer) {
+-            serverPlayer.sendSystemMessage(this.getCombatTracker().getDeathMessage());
+            // Paper start - Add TameableDeathMessageEvent
+            io.papermc.paper.event.entity.TameableDeathMessageEvent event = new io.papermc.paper.event.entity.TameableDeathMessageEvent((org.bukkit.entity.Tameable) getBukkitEntity(), io.papermc.paper.adventure.PaperAdventure.asAdventure(this.getCombatTracker().getDeathMessage()));
+            if (event.callEvent()) {
+                serverPlayer.sendSystemMessage(io.papermc.paper.adventure.PaperAdventure.asVanilla(event.deathMessage()));
+            }
+            // Paper end - Add TameableDeathMessageEvent
+         }
+ 
+         super.die(cause);
+@@ -270,7 +_,14 @@
+         if (!this.canTeleportTo(new BlockPos(x, y, z))) {
+             return false;
+         } else {
+-            this.moveTo(x + 0.5, y, z + 0.5, this.getYRot(), this.getXRot());
+            // CraftBukkit start
+            org.bukkit.event.entity.EntityTeleportEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityTeleportEvent(this, x + 0.5D, y, z + 0.5D);
+            if (event.isCancelled() || event.getTo() == null) { // Paper - prevent NP on null event to location
+                return false;
+            }
+            org.bukkit.Location to = event.getTo();
+            this.moveTo(to.getX(), to.getY(), to.getZ(), to.getYaw(), to.getPitch());
+            // CraftBukkit end
+             this.navigation.stop();
+             return true;
+         }