PaperMC/paper-server/patches/sources/net/minecraft/world/entity/Mob.java.patch

--- 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().findNearbyPlayer(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(equipmentSlot);
+                    }
+                    // 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, creatureSpawnReason);
+    }
+    @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));
             }