add remapped patches as a testsoftspoon

1 files changed, 1732 insertions, 0 deletions

diff --git a/patch-remap/mache-vineflower/net/minecraft/world/entity/Mob.java.patch b/patch-remap/mache-vineflower/net/minecraft/world/entity/Mob.java.patch
new file mode 100644
index 0000000000..143349d38a
--- /dev/null
+++ b/patch-remap/mache-vineflower/net/minecraft/world/entity/Mob.java.patch
@@ -0,0 +1,1732 @@
+--- a/net/minecraft/world/entity/Mob.java
++++ b/net/minecraft/world/entity/Mob.java
+@@ -3,6 +3,8 @@
+ import com.google.common.annotations.VisibleForTesting;
+ import com.google.common.collect.Maps;
+ import java.util.Arrays;
++import java.util.Iterator;
++import java.util.List;
+ import java.util.Map;
+ import java.util.Optional;
+ import java.util.UUID;
+@@ -23,13 +25,14 @@
+ import net.minecraft.network.syncher.SynchedEntityData;
+ import net.minecraft.resources.ResourceLocation;
+ import net.minecraft.server.level.ServerLevel;
++import net.minecraft.server.level.ServerPlayer;
+ import net.minecraft.sounds.SoundEvent;
+ import net.minecraft.tags.TagKey;
+ import net.minecraft.util.Mth;
+ import net.minecraft.util.RandomSource;
+ import net.minecraft.world.Difficulty;
+ import net.minecraft.world.DifficultyInstance;
+-import net.minecraft.world.InteractionHand;
++import net.minecraft.world.EnumHand;
+ import net.minecraft.world.InteractionResult;
+ import net.minecraft.world.damagesource.DamageSource;
+ import net.minecraft.world.entity.ai.attributes.AttributeModifier;
+@@ -47,7 +50,7 @@
+ import net.minecraft.world.entity.decoration.HangingEntity;
+ import net.minecraft.world.entity.decoration.LeashFenceKnotEntity;
+ import net.minecraft.world.entity.item.ItemEntity;
+-import net.minecraft.world.entity.monster.Enemy;
++import net.minecraft.world.entity.monster.IMonster;
+ import net.minecraft.world.entity.player.Player;
+ import net.minecraft.world.entity.vehicle.Boat;
+ import net.minecraft.world.item.ArmorItem;
+@@ -64,6 +67,7 @@
+ import net.minecraft.world.item.SwordItem;
+ import net.minecraft.world.item.enchantment.EnchantmentHelper;
+ import net.minecraft.world.level.GameRules;
++import net.minecraft.world.level.IMaterial;
+ import net.minecraft.world.level.Level;
+ import net.minecraft.world.level.LevelAccessor;
+ import net.minecraft.world.level.LevelReader;
+@@ -72,8 +76,19 @@
+ import net.minecraft.world.level.material.Fluid;
+ import net.minecraft.world.level.pathfinder.BlockPathTypes;
+ import net.minecraft.world.phys.AABB;
++import org.bukkit.craftbukkit.event.CraftEventFactory;
++import org.bukkit.craftbukkit.entity.CraftLivingEntity;
++import org.bukkit.event.entity.CreatureSpawnEvent;
++import org.bukkit.event.entity.EntityCombustByEntityEvent;
++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 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;
+     private static final int MOB_FLAG_LEFTHANDED = 2;
+@@ -88,7 +103,7 @@
+     public static final float DEFAULT_EQUIPMENT_DROP_CHANCE = 0.085F;
+     public static final int PRESERVE_ITEM_DROP_CHANCE = 2;
+     public static final int UPDATE_GOAL_SELECTOR_EVERY_N_TICKS = 2;
+-    private static final double DEFAULT_ATTACK_REACH = Math.sqrt(2.04F) - 0.6F;
++    private static final double DEFAULT_ATTACK_REACH = Math.sqrt(2.0399999618530273D) - 0.6000000238418579D;
+     public int ambientSoundTime;
+     protected int xpReward;
+     protected LookControl lookControl;
+@@ -96,31 +111,40 @@
+     protected JumpControl jumpControl;
+     private final BodyRotationControl bodyRotationControl;
+     protected PathNavigation navigation;
+-    protected final GoalSelector goalSelector;
+-    protected final GoalSelector targetSelector;
++    public GoalSelector goalSelector;
++    public GoalSelector targetSelector;
+     @Nullable
+     private LivingEntity target;
+     private final Sensing sensing;
+-    private final NonNullList<ItemStack> handItems = NonNullList.withSize(2, ItemStack.EMPTY);
+-    protected final float[] handDropChances = new float[2];
+-    private final NonNullList<ItemStack> armorItems = NonNullList.withSize(4, ItemStack.EMPTY);
+-    protected final float[] armorDropChances = new float[4];
++    private final NonNullList<ItemStack> handItems;
++    public final float[] handDropChances;
++    private final NonNullList<ItemStack> armorItems;
++    public final float[] armorDropChances;
+     private boolean canPickUpLoot;
+     private boolean persistenceRequired;
+-    private final Map<BlockPathTypes, Float> pathfindingMalus = Maps.newEnumMap(BlockPathTypes.class);
++    private final Map<BlockPathTypes, Float> pathfindingMalus;
+     @Nullable
+-    private ResourceLocation lootTable;
+-    private long lootTableSeed;
++    public ResourceLocation lootTable;
++    public long lootTableSeed;
+     @Nullable
+     private Entity leashHolder;
+     private int delayedLeashHolderId;
+     @Nullable
+     private CompoundTag leashInfoTag;
+-    private BlockPos restrictCenter = BlockPos.ZERO;
+-    private float restrictRadius = -1.0F;
++    private BlockPos restrictCenter;
++    private float restrictRadius;
+ 
++    public boolean aware = true; // CraftBukkit
++
+     protected Mob(EntityType<? extends Mob> entityType, Level level) {
+         super(entityType, level);
++        this.handItems = NonNullList.withSize(2, ItemStack.EMPTY);
++        this.handDropChances = new float[2];
++        this.armorItems = NonNullList.withSize(4, ItemStack.EMPTY);
++        this.armorDropChances = new float[4];
++        this.pathfindingMalus = Maps.newEnumMap(BlockPathTypes.class);
++        this.restrictCenter = BlockPos.ZERO;
++        this.restrictRadius = -1.0F;
+         this.goalSelector = new GoalSelector(level.getProfilerSupplier());
+         this.targetSelector = new GoalSelector(level.getProfilerSupplier());
+         this.lookControl = new LookControl(this);
+@@ -134,13 +158,19 @@
+         if (level != null && !level.isClientSide) {
+             this.registerGoals();
+         }
++
+     }
+ 
+-    protected void registerGoals() {
++    // CraftBukkit start
++    public void setPersistenceRequired(boolean persistenceRequired) {
++        this.persistenceRequired = persistenceRequired;
+     }
++    // CraftBukkit end
+ 
++    protected void registerGoals() {}
++
+     public static AttributeSupplier.Builder createMobAttributes() {
+-        return LivingEntity.createLivingAttributes().add(Attributes.FOLLOW_RANGE, 16.0).add(Attributes.ATTACK_KNOCKBACK);
++        return LivingEntity.createLivingAttributes().add(Attributes.FOLLOW_RANGE, 16.0D).add(Attributes.ATTACK_KNOCKBACK);
+     }
+ 
+     protected PathNavigation createNavigation(Level level) {
+@@ -152,29 +182,35 @@
+     }
+ 
+     public float getPathfindingMalus(BlockPathTypes nodeType) {
+-        Mob mob1;
+-        label17: {
+-            if (this.getControlledVehicle() instanceof Mob mob && mob.shouldPassengersInheritMalus()) {
+-                mob1 = mob;
+-                break label17;
++        Mob entityinsentient;
++        label17:
++        {
++            Entity entity = this.getControlledVehicle();
++
++            if (entity instanceof Mob) {
++                Mob entityinsentient1 = (Mob) entity;
++
++                if (entityinsentient1.shouldPassengersInheritMalus()) {
++                    entityinsentient = entityinsentient1;
++                    break label17;
++                }
+             }
+ 
+-            mob1 = this;
++            entityinsentient = this;
+         }
+ 
+-        Float _float = mob1.pathfindingMalus.get(nodeType);
+-        return _float == null ? nodeType.getMalus() : _float;
++        Float ofloat = (Float) entityinsentient.pathfindingMalus.get(nodeType);
++
++        return ofloat == null ? nodeType.getMalus() : ofloat;
+     }
+ 
+     public void setPathfindingMalus(BlockPathTypes nodeType, float malus) {
+         this.pathfindingMalus.put(nodeType, malus);
+     }
+ 
+-    public void onPathfindingStart() {
+-    }
++    public void onPathfindingStart() {}
+ 
+-    public void onPathfindingDone() {
+-    }
++    public void onPathfindingDone() {}
+ 
+     protected BodyRotationControl createBodyControl() {
+         return new BodyRotationControl(this);
+@@ -185,7 +221,15 @@
+     }
+ 
+     public MoveControl getMoveControl() {
+-        return this.getControlledVehicle() instanceof Mob mob ? mob.getMoveControl() : this.moveControl;
++        Entity entity = this.getControlledVehicle();
++
++        if (entity instanceof Mob) {
++            Mob entityinsentient = (Mob) entity;
++
++            return entityinsentient.getMoveControl();
++        } else {
++            return this.moveControl;
++        }
+     }
+ 
+     public JumpControl getJumpControl() {
+@@ -193,18 +237,34 @@
+     }
+ 
+     public PathNavigation getNavigation() {
+-        return this.getControlledVehicle() instanceof Mob mob ? mob.getNavigation() : this.navigation;
++        Entity entity = this.getControlledVehicle();
++
++        if (entity instanceof Mob) {
++            Mob entityinsentient = (Mob) entity;
++
++            return entityinsentient.getNavigation();
++        } else {
++            return this.navigation;
++        }
+     }
+ 
+     @Nullable
+     @Override
+     public LivingEntity getControllingPassenger() {
+-        Entity firstPassenger = this.getFirstPassenger();
+-        if (!this.isNoAi() && firstPassenger instanceof Mob mob && firstPassenger.canControlVehicle()) {
+-            return mob;
++        Entity entity = this.getFirstPassenger();
++        Mob entityinsentient;
++
++        if (!this.isNoAi() && entity instanceof Mob) {
++            Mob entityinsentient1 = (Mob) entity;
++
++            if (entity.canControlVehicle()) {
++                entityinsentient = entityinsentient1;
++                return entityinsentient;
++            }
+         }
+ 
+-        return null;
++        entityinsentient = null;
++        return entityinsentient;
+     }
+ 
+     public Sensing getSensing() {
+@@ -218,9 +278,40 @@
+     }
+ 
+     public void setTarget(@Nullable LivingEntity target) {
+-        this.target = target;
++        // CraftBukkit start - fire event
++        setTarget(target, EntityTargetEvent.TargetReason.UNKNOWN, true);
+     }
+ 
++    public boolean setTarget(LivingEntity entityliving, EntityTargetEvent.TargetReason reason, boolean fireEvent) {
++        if (getTarget() == entityliving) return false;
++        if (fireEvent) {
++            if (reason == EntityTargetEvent.TargetReason.UNKNOWN && getTarget() != null && entityliving == null) {
++                reason = 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 (entityliving != null) {
++                ctarget = (CraftLivingEntity) entityliving.getBukkitEntity();
++            }
++            EntityTargetLivingEntityEvent event = new EntityTargetLivingEntityEvent(this.getBukkitEntity(), ctarget, reason);
++            this.level().getCraftServer().getPluginManager().callEvent(event);
++            if (event.isCancelled()) {
++                return false;
++            }
++
++            if (event.getTarget() != null) {
++                entityliving = ((CraftLivingEntity) event.getTarget()).getHandle();
++            } else {
++                entityliving = null;
++            }
++        }
++        this.target = entityliving;
++        return true;
++        // CraftBukkit end
++    }
++
+     @Override
+     public boolean canAttackType(EntityType<?> type) {
+         return type != EntityType.GHAST;
+@@ -237,7 +328,7 @@
+     @Override
+     protected void defineSynchedData() {
+         super.defineSynchedData();
+-        this.entityData.define(DATA_MOB_FLAGS_ID, (byte)0);
++        this.entityData.define(Mob.DATA_MOB_FLAGS_ID, (byte) 0);
+     }
+ 
+     public int getAmbientSoundInterval() {
+@@ -245,10 +336,12 @@
+     }
+ 
+     public void playAmbientSound() {
+-        SoundEvent ambientSound = this.getAmbientSound();
+-        if (ambientSound != null) {
+-            this.playSound(ambientSound, this.getSoundVolume(), this.getVoicePitch());
++        SoundEvent soundeffect = this.getAmbientSound();
++
++        if (soundeffect != null) {
++            this.playSound(soundeffect, this.getSoundVolume(), this.getVoicePitch());
+         }
++
+     }
+ 
+     @Override
+@@ -278,14 +371,16 @@
+         if (this.xpReward > 0) {
+             int i = this.xpReward;
+ 
+-            for (int i1 = 0; i1 < this.armorItems.size(); i1++) {
+-                if (!this.armorItems.get(i1).isEmpty() && this.armorDropChances[i1] <= 1.0F) {
++            int j;
++
++            for (j = 0; j < this.armorItems.size(); ++j) {
++                if (!((ItemStack) this.armorItems.get(j)).isEmpty() && this.armorDropChances[j] <= 1.0F) {
+                     i += 1 + this.random.nextInt(3);
+                 }
+             }
+ 
+-            for (int i1x = 0; i1x < this.handItems.size(); i1x++) {
+-                if (!this.handItems.get(i1x).isEmpty() && this.handDropChances[i1x] <= 1.0F) {
++            for (j = 0; j < this.handItems.size(); ++j) {
++                if (!((ItemStack) this.handItems.get(j)).isEmpty() && this.handDropChances[j] <= 1.0F) {
+                     i += 1 + this.random.nextInt(3);
+                 }
+             }
+@@ -298,17 +393,18 @@
+ 
+     public void spawnAnim() {
+         if (this.level().isClientSide) {
+-            for (int i = 0; i < 20; i++) {
+-                double d = this.random.nextGaussian() * 0.02;
+-                double d1 = this.random.nextGaussian() * 0.02;
+-                double d2 = this.random.nextGaussian() * 0.02;
+-                double d3 = 10.0;
+-                this.level()
+-                    .addParticle(ParticleTypes.POOF, this.getX(1.0) - d * 10.0, this.getRandomY() - d1 * 10.0, this.getRandomZ(1.0) - d2 * 10.0, d, d1, d2);
++            for (int i = 0; i < 20; ++i) {
++                double d0 = this.random.nextGaussian() * 0.02D;
++                double d1 = this.random.nextGaussian() * 0.02D;
++                double d2 = this.random.nextGaussian() * 0.02D;
++                double d3 = 10.0D;
++
++                this.level().addParticle(ParticleTypes.POOF, this.getX(1.0D) - d0 * 10.0D, this.getRandomY() - d1 * 10.0D, this.getRandomZ(1.0D) - d2 * 10.0D, d0, d1, d2);
+             }
+         } else {
+-            this.level().broadcastEntityEvent(this, (byte)20);
++            this.level().broadcastEntityEvent(this, (byte) 20);
+         }
++
+     }
+ 
+     @Override
+@@ -318,6 +414,7 @@
+         } else {
+             super.handleEntityEvent(id);
+         }
++
+     }
+ 
+     @Override
+@@ -329,14 +426,16 @@
+                 this.updateControlFlags();
+             }
+         }
++
+     }
+ 
+     protected void updateControlFlags() {
+         boolean flag = !(this.getControllingPassenger() instanceof Mob);
+         boolean flag1 = !(this.getVehicle() instanceof Boat);
+-        this.goalSelector.setControlFlag(Goal.Flag.MOVE, flag);
+-        this.goalSelector.setControlFlag(Goal.Flag.JUMP, flag && flag1);
+-        this.goalSelector.setControlFlag(Goal.Flag.LOOK, flag);
++
++        this.goalSelector.setControlFlag(Goal.Type.MOVE, flag);
++        this.goalSelector.setControlFlag(Goal.Type.JUMP, flag && flag1);
++        this.goalSelector.setControlFlag(Goal.Type.LOOK, flag);
+     }
+ 
+     @Override
+@@ -350,62 +449,85 @@
+         return null;
+     }
+ 
++    // CraftBukkit start - Add delegate method
++    public SoundEvent getAmbientSound0() {
++        return getAmbientSound();
++    }
++    // CraftBukkit end
++
+     @Override
+     public void addAdditionalSaveData(CompoundTag compound) {
+         super.addAdditionalSaveData(compound);
+         compound.putBoolean("CanPickUpLoot", this.canPickUpLoot());
+         compound.putBoolean("PersistenceRequired", this.persistenceRequired);
+-        ListTag list = new ListTag();
++        ListTag nbttaglist = new ListTag();
+ 
+-        for (ItemStack itemStack : this.armorItems) {
+-            CompoundTag compoundTag = new CompoundTag();
+-            if (!itemStack.isEmpty()) {
+-                itemStack.save(compoundTag);
+-            }
++        CompoundTag nbttagcompound1;
+ 
+-            list.add(compoundTag);
++        for (Iterator iterator = this.armorItems.iterator(); iterator.hasNext(); nbttaglist.add(nbttagcompound1)) {
++            ItemStack itemstack = (ItemStack) iterator.next();
++
++            nbttagcompound1 = new CompoundTag();
++            if (!itemstack.isEmpty()) {
++                itemstack.save(nbttagcompound1);
++            }
+         }
+ 
+-        compound.put("ArmorItems", list);
+-        ListTag list1 = new ListTag();
++        compound.put("ArmorItems", nbttaglist);
++        ListTag nbttaglist1 = new ListTag();
+ 
+-        for (ItemStack itemStack1 : this.handItems) {
+-            CompoundTag compoundTag1 = new CompoundTag();
+-            if (!itemStack1.isEmpty()) {
+-                itemStack1.save(compoundTag1);
+-            }
++        CompoundTag nbttagcompound2;
+ 
+-            list1.add(compoundTag1);
++        for (Iterator iterator1 = this.handItems.iterator(); iterator1.hasNext(); nbttaglist1.add(nbttagcompound2)) {
++            ItemStack itemstack1 = (ItemStack) iterator1.next();
++
++            nbttagcompound2 = new CompoundTag();
++            if (!itemstack1.isEmpty()) {
++                itemstack1.save(nbttagcompound2);
++            }
+         }
+ 
+-        compound.put("HandItems", list1);
+-        ListTag list2 = new ListTag();
++        compound.put("HandItems", nbttaglist1);
++        ListTag nbttaglist2 = new ListTag();
++        float[] afloat = this.armorDropChances;
++        int i = afloat.length;
+ 
+-        for (float f : this.armorDropChances) {
+-            list2.add(FloatTag.valueOf(f));
++        int j;
++
++        for (j = 0; j < i; ++j) {
++            float f = afloat[j];
++
++            nbttaglist2.add(FloatTag.valueOf(f));
+         }
+ 
+-        compound.put("ArmorDropChances", list2);
+-        ListTag list3 = new ListTag();
++        compound.put("ArmorDropChances", nbttaglist2);
++        ListTag nbttaglist3 = new ListTag();
++        float[] afloat1 = this.handDropChances;
+ 
+-        for (float f1 : this.handDropChances) {
+-            list3.add(FloatTag.valueOf(f1));
++        j = afloat1.length;
++
++        for (int k = 0; k < j; ++k) {
++            float f1 = afloat1[k];
++
++            nbttaglist3.add(FloatTag.valueOf(f1));
+         }
+ 
+-        compound.put("HandDropChances", list3);
+-        if (this.leashHolder != null) {
+-            CompoundTag compoundTag1 = new CompoundTag();
++        compound.put("HandDropChances", nbttaglist3);
++        if (this.leashHolder != null && !this.leashHolder.pluginRemoved) { // CraftBukkit - SPIGOT-7487: Don't save (and possible drop) leash, when the holder was removed by a plugin
++            nbttagcompound2 = new CompoundTag();
+             if (this.leashHolder instanceof LivingEntity) {
+-                UUID uUID = this.leashHolder.getUUID();
+-                compoundTag1.putUUID("UUID", uUID);
++                UUID uuid = this.leashHolder.getUUID();
++
++                nbttagcompound2.putUUID("UUID", uuid);
+             } else if (this.leashHolder instanceof HangingEntity) {
+-                BlockPos pos = ((HangingEntity)this.leashHolder).getPos();
+-                compoundTag1.putInt("X", pos.getX());
+-                compoundTag1.putInt("Y", pos.getY());
+-                compoundTag1.putInt("Z", pos.getZ());
++                BlockPos blockposition = ((HangingEntity) this.leashHolder).getPos();
++
++                nbttagcompound2.putInt("X", blockposition.getX());
++                nbttagcompound2.putInt("Y", blockposition.getY());
++                nbttagcompound2.putInt("Z", blockposition.getZ());
+             }
+ 
+-            compound.put("Leash", compoundTag1);
++            compound.put("Leash", nbttagcompound2);
+         } else if (this.leashInfoTag != null) {
+             compound.put("Leash", this.leashInfoTag.copy());
+         }
+@@ -421,45 +543,59 @@
+         if (this.isNoAi()) {
+             compound.putBoolean("NoAI", this.isNoAi());
+         }
++
++        compound.putBoolean("Bukkit.Aware", this.aware); // CraftBukkit
+     }
+ 
+     @Override
+     public void readAdditionalSaveData(CompoundTag compound) {
+         super.readAdditionalSaveData(compound);
++
++        // CraftBukkit start - If looting or persistence is false only use it if it was set after we started using it
+         if (compound.contains("CanPickUpLoot", 1)) {
+-            this.setCanPickUpLoot(compound.getBoolean("CanPickUpLoot"));
++            boolean data = compound.getBoolean("CanPickUpLoot");
++            if (isLevelAtLeast(compound, 1) || data) {
++                this.setCanPickUpLoot(data);
++            }
+         }
+ 
+-        this.persistenceRequired = compound.getBoolean("PersistenceRequired");
++        boolean data = compound.getBoolean("PersistenceRequired");
++        if (isLevelAtLeast(compound, 1) || data) {
++            this.persistenceRequired = data;
++        }
++        // CraftBukkit end
++        ListTag nbttaglist;
++        int i;
++
+         if (compound.contains("ArmorItems", 9)) {
+-            ListTag list = compound.getList("ArmorItems", 10);
++            nbttaglist = compound.getList("ArmorItems", 10);
+ 
+-            for (int i = 0; i < this.armorItems.size(); i++) {
+-                this.armorItems.set(i, ItemStack.of(list.getCompound(i)));
++            for (i = 0; i < this.armorItems.size(); ++i) {
++                this.armorItems.set(i, ItemStack.of(nbttaglist.getCompound(i)));
+             }
+         }
+ 
+         if (compound.contains("HandItems", 9)) {
+-            ListTag list = compound.getList("HandItems", 10);
++            nbttaglist = compound.getList("HandItems", 10);
+ 
+-            for (int i = 0; i < this.handItems.size(); i++) {
+-                this.handItems.set(i, ItemStack.of(list.getCompound(i)));
++            for (i = 0; i < this.handItems.size(); ++i) {
++                this.handItems.set(i, ItemStack.of(nbttaglist.getCompound(i)));
+             }
+         }
+ 
+         if (compound.contains("ArmorDropChances", 9)) {
+-            ListTag list = compound.getList("ArmorDropChances", 5);
++            nbttaglist = compound.getList("ArmorDropChances", 5);
+ 
+-            for (int i = 0; i < list.size(); i++) {
+-                this.armorDropChances[i] = list.getFloat(i);
++            for (i = 0; i < nbttaglist.size(); ++i) {
++                this.armorDropChances[i] = nbttaglist.getFloat(i);
+             }
+         }
+ 
+         if (compound.contains("HandDropChances", 9)) {
+-            ListTag list = compound.getList("HandDropChances", 5);
++            nbttaglist = compound.getList("HandDropChances", 5);
+ 
+-            for (int i = 0; i < list.size(); i++) {
+-                this.handDropChances[i] = list.getFloat(i);
++            for (i = 0; i < nbttaglist.size(); ++i) {
++                this.handDropChances[i] = nbttaglist.getFloat(i);
+             }
+         }
+ 
+@@ -474,6 +610,11 @@
+         }
+ 
+         this.setNoAi(compound.getBoolean("NoAI"));
++        // CraftBukkit start
++        if (compound.contains("Bukkit.Aware")) {
++            this.aware = compound.getBoolean("Bukkit.Aware");
++        }
++        // CraftBukkit end
+     }
+ 
+     @Override
+@@ -487,7 +628,7 @@
+         return this.lootTable == null ? this.getDefaultLootTable() : this.lootTable;
+     }
+ 
+-    protected ResourceLocation getDefaultLootTable() {
++    public ResourceLocation getDefaultLootTable() {
+         return super.getLootTable();
+     }
+ 
+@@ -518,19 +659,16 @@
+     public void aiStep() {
+         super.aiStep();
+         this.level().getProfiler().push("looting");
+-        if (!this.level().isClientSide
+-            && this.canPickUpLoot()
+-            && this.isAlive()
+-            && !this.dead
+-            && this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
+-            Vec3i pickupReach = this.getPickupReach();
++        if (!this.level().isClientSide && this.canPickUpLoot() && this.isAlive() && !this.dead && this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
++            Vec3i baseblockposition = this.getPickupReach();
++            List<ItemEntity> list = this.level().getEntitiesOfClass(ItemEntity.class, this.getBoundingBox().inflate((double) baseblockposition.getX(), (double) baseblockposition.getY(), (double) baseblockposition.getZ()));
++            Iterator iterator = list.iterator();
+ 
+-            for (ItemEntity itemEntity : this.level()
+-                .getEntitiesOfClass(
+-                    ItemEntity.class, this.getBoundingBox().inflate((double)pickupReach.getX(), (double)pickupReach.getY(), (double)pickupReach.getZ())
+-                )) {
+-                if (!itemEntity.isRemoved() && !itemEntity.getItem().isEmpty() && !itemEntity.hasPickUpDelay() && this.wantsToPickUp(itemEntity.getItem())) {
+-                    this.pickUpItem(itemEntity);
++            while (iterator.hasNext()) {
++                ItemEntity entityitem = (ItemEntity) iterator.next();
++
++                if (!entityitem.isRemoved() && !entityitem.getItem().isEmpty() && !entityitem.hasPickUpDelay() && this.wantsToPickUp(entityitem.getItem())) {
++                    this.pickUpItem(entityitem);
+                 }
+             }
+         }
+@@ -539,45 +677,64 @@
+     }
+ 
+     protected Vec3i getPickupReach() {
+-        return ITEM_PICKUP_REACH;
++        return Mob.ITEM_PICKUP_REACH;
+     }
+ 
+     protected void pickUpItem(ItemEntity itemEntity) {
+-        ItemStack item = itemEntity.getItem();
+-        ItemStack itemStack = this.equipItemIfPossible(item.copy());
+-        if (!itemStack.isEmpty()) {
++        ItemStack itemstack = itemEntity.getItem();
++        ItemStack itemstack1 = this.equipItemIfPossible(itemstack.copy(), itemEntity); // CraftBukkit - add item
++
++        if (!itemstack1.isEmpty()) {
+             this.onItemPickup(itemEntity);
+-            this.take(itemEntity, itemStack.getCount());
+-            item.shrink(itemStack.getCount());
+-            if (item.isEmpty()) {
++            this.take(itemEntity, itemstack1.getCount());
++            itemstack.shrink(itemstack1.getCount());
++            if (itemstack.isEmpty()) {
+                 itemEntity.discard();
+             }
+         }
++
+     }
+ 
+     public ItemStack equipItemIfPossible(ItemStack stack) {
+-        EquipmentSlot equipmentSlotForItem = getEquipmentSlotForItem(stack);
+-        ItemStack itemBySlot = this.getItemBySlot(equipmentSlotForItem);
+-        boolean canReplaceCurrentItem = this.canReplaceCurrentItem(stack, itemBySlot);
+-        if (equipmentSlotForItem.isArmor() && !canReplaceCurrentItem) {
+-            equipmentSlotForItem = EquipmentSlot.MAINHAND;
+-            itemBySlot = this.getItemBySlot(equipmentSlotForItem);
+-            canReplaceCurrentItem = itemBySlot.isEmpty();
++        // CraftBukkit start - add item
++        return this.equipItemIfPossible(stack, null);
++    }
++
++    public ItemStack equipItemIfPossible(ItemStack itemstack, ItemEntity entityitem) {
++        // CraftBukkit end
++        EquipmentSlot enumitemslot = getEquipmentSlotForItem(itemstack);
++        ItemStack itemstack1 = this.getItemBySlot(enumitemslot);
++        boolean flag = this.canReplaceCurrentItem(itemstack, itemstack1);
++
++        if (enumitemslot.isArmor() && !flag) {
++            enumitemslot = EquipmentSlot.MAINHAND;
++            itemstack1 = this.getItemBySlot(enumitemslot);
++            flag = itemstack1.isEmpty();
+         }
+ 
+-        if (canReplaceCurrentItem && this.canHoldItem(stack)) {
+-            double d = (double)this.getEquipmentDropChance(equipmentSlotForItem);
+-            if (!itemBySlot.isEmpty() && (double)Math.max(this.random.nextFloat() - 0.1F, 0.0F) < d) {
+-                this.spawnAtLocation(itemBySlot);
++        // CraftBukkit start
++        boolean canPickup = flag && this.canHoldItem(itemstack);
++        if (entityitem != null) {
++            canPickup = !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityPickupItemEvent(this, entityitem, 0, !canPickup).isCancelled();
++        }
++        if (canPickup) {
++            // CraftBukkit end
++            double d0 = (double) this.getEquipmentDropChance(enumitemslot);
++
++            if (!itemstack1.isEmpty() && (double) Math.max(this.random.nextFloat() - 0.1F, 0.0F) < d0) {
++                this.forceDrops = true; // CraftBukkit
++                this.spawnAtLocation(itemstack1);
++                this.forceDrops = false; // CraftBukkit
+             }
+ 
+-            if (equipmentSlotForItem.isArmor() && stack.getCount() > 1) {
+-                ItemStack itemStack = stack.copyWithCount(1);
+-                this.setItemSlotAndDropWhenKilled(equipmentSlotForItem, itemStack);
+-                return itemStack;
++            if (enumitemslot.isArmor() && itemstack.getCount() > 1) {
++                ItemStack itemstack2 = itemstack.copyWithCount(1);
++
++                this.setItemSlotAndDropWhenKilled(enumitemslot, itemstack2);
++                return itemstack2;
+             } else {
+-                this.setItemSlotAndDropWhenKilled(equipmentSlotForItem, stack);
+-                return stack;
++                this.setItemSlotAndDropWhenKilled(enumitemslot, itemstack);
++                return itemstack;
+             }
+         } else {
+             return ItemStack.EMPTY;
+@@ -598,6 +755,7 @@
+             case ARMOR:
+                 this.armorDropChances[slot.getIndex()] = 2.0F;
+         }
++
+     }
+ 
+     protected boolean canReplaceCurrentItem(ItemStack candidate, ItemStack existing) {
+@@ -607,58 +765,61 @@
+             if (!(existing.getItem() instanceof SwordItem)) {
+                 return true;
+             } else {
+-                SwordItem swordItem = (SwordItem)candidate.getItem();
+-                SwordItem swordItem1 = (SwordItem)existing.getItem();
+-                return swordItem.getDamage() != swordItem1.getDamage()
+-                    ? swordItem.getDamage() > swordItem1.getDamage()
+-                    : this.canReplaceEqualItem(candidate, existing);
++                SwordItem itemsword = (SwordItem) candidate.getItem();
++                SwordItem itemsword1 = (SwordItem) existing.getItem();
++
++                return itemsword.getDamage() != itemsword1.getDamage() ? itemsword.getDamage() > itemsword1.getDamage() : this.canReplaceEqualItem(candidate, existing);
+             }
+         } else if (candidate.getItem() instanceof BowItem && existing.getItem() instanceof BowItem) {
+             return this.canReplaceEqualItem(candidate, existing);
+         } else if (candidate.getItem() instanceof CrossbowItem && existing.getItem() instanceof CrossbowItem) {
+             return this.canReplaceEqualItem(candidate, existing);
+-        } else if (candidate.getItem() instanceof ArmorItem armorItem) {
+-            if (EnchantmentHelper.hasBindingCurse(existing)) {
+-                return false;
+-            } else if (!(existing.getItem() instanceof ArmorItem)) {
+-                return true;
+-            } else {
+-                ArmorItem armorItem1 = (ArmorItem)existing.getItem();
+-                if (armorItem.getDefense() != armorItem1.getDefense()) {
+-                    return armorItem.getDefense() > armorItem1.getDefense();
+-                } else {
+-                    return armorItem.getToughness() != armorItem1.getToughness()
+-                        ? armorItem.getToughness() > armorItem1.getToughness()
+-                        : this.canReplaceEqualItem(candidate, existing);
+-                }
+-            }
+         } else {
+-            if (candidate.getItem() instanceof DiggerItem) {
+-                if (existing.getItem() instanceof BlockItem) {
++            Item item = candidate.getItem();
++
++            if (item instanceof ArmorItem) {
++                ArmorItem itemarmor = (ArmorItem) item;
++
++                if (EnchantmentHelper.hasBindingCurse(existing)) {
++                    return false;
++                } else if (!(existing.getItem() instanceof ArmorItem)) {
+                     return true;
+-                }
++                } else {
++                    ArmorItem itemarmor1 = (ArmorItem) existing.getItem();
+ 
+-                if (existing.getItem() instanceof DiggerItem diggerItem) {
+-                    DiggerItem diggerItem1 = (DiggerItem)candidate.getItem();
+-                    if (diggerItem1.getAttackDamage() != diggerItem.getAttackDamage()) {
+-                        return diggerItem1.getAttackDamage() > diggerItem.getAttackDamage();
++                    return itemarmor.getDefense() != itemarmor1.getDefense() ? itemarmor.getDefense() > itemarmor1.getDefense() : (itemarmor.getToughness() != itemarmor1.getToughness() ? itemarmor.getToughness() > itemarmor1.getToughness() : this.canReplaceEqualItem(candidate, existing));
++                }
++            } else {
++                if (candidate.getItem() instanceof DiggerItem) {
++                    if (existing.getItem() instanceof BlockItem) {
++                        return true;
+                     }
+ 
+-                    return this.canReplaceEqualItem(candidate, existing);
++                    Item item1 = existing.getItem();
++
++                    if (item1 instanceof DiggerItem) {
++                        DiggerItem itemtool = (DiggerItem) item1;
++                        DiggerItem itemtool1 = (DiggerItem) candidate.getItem();
++
++                        if (itemtool1.getAttackDamage() != itemtool.getAttackDamage()) {
++                            return itemtool1.getAttackDamage() > itemtool.getAttackDamage();
++                        }
++
++                        return this.canReplaceEqualItem(candidate, existing);
++                    }
+                 }
+-            }
+ 
+-            return false;
++                return false;
++            }
+         }
+     }
+ 
+     public boolean canReplaceEqualItem(ItemStack candidate, ItemStack existing) {
+-        return candidate.getDamageValue() < existing.getDamageValue()
+-            || candidate.hasTag() && !existing.hasTag()
+-            || candidate.hasTag()
+-                && existing.hasTag()
+-                && candidate.getTag().getAllKeys().stream().anyMatch(stack -> !stack.equals("Damage"))
+-                && !existing.getTag().getAllKeys().stream().anyMatch(stack -> !stack.equals("Damage"));
++        return candidate.getDamageValue() >= existing.getDamageValue() && (!candidate.hasTag() || existing.hasTag()) ? (candidate.hasTag() && existing.hasTag() ? candidate.getTag().getAllKeys().stream().anyMatch((s) -> {
++            return !s.equals("Damage");
++        }) && !existing.getTag().getAllKeys().stream().anyMatch((s) -> {
++            return !s.equals("Damage");
++        }) : false) : true;
+     }
+ 
+     public boolean canHoldItem(ItemStack stack) {
+@@ -686,23 +847,27 @@
+         if (this.level().getDifficulty() == Difficulty.PEACEFUL && this.shouldDespawnInPeaceful()) {
+             this.discard();
+         } else if (!this.isPersistenceRequired() && !this.requiresCustomPersistence()) {
+-            Entity nearestPlayer = this.level().getNearestPlayer(this, -1.0);
+-            if (nearestPlayer != null) {
+-                double d = nearestPlayer.distanceToSqr(this);
+-                int despawnDistance = this.getType().getCategory().getDespawnDistance();
+-                int i = despawnDistance * despawnDistance;
+-                if (d > (double)i && this.removeWhenFarAway(d)) {
++            Player entityhuman = this.level().getNearestPlayer(this, -1.0D);
++
++            if (entityhuman != null) {
++                double d0 = entityhuman.distanceToSqr((Entity) this);
++                int i = this.getType().getCategory().getDespawnDistance();
++                int j = i * i;
++
++                if (d0 > (double) j && this.removeWhenFarAway(d0)) {
+                     this.discard();
+                 }
+ 
+-                int noDespawnDistance = this.getType().getCategory().getNoDespawnDistance();
+-                int i1 = noDespawnDistance * noDespawnDistance;
+-                if (this.noActionTime > 600 && this.random.nextInt(800) == 0 && d > (double)i1 && this.removeWhenFarAway(d)) {
++                int k = this.getType().getCategory().getNoDespawnDistance();
++                int l = k * k;
++
++                if (this.noActionTime > 600 && this.random.nextInt(800) == 0 && d0 > (double) l && this.removeWhenFarAway(d0)) {
+                     this.discard();
+-                } else if (d < (double)i1) {
++                } else if (d0 < (double) l) {
+                     this.noActionTime = 0;
+                 }
+             }
++
+         } else {
+             this.noActionTime = 0;
+         }
+@@ -710,11 +875,13 @@
+ 
+     @Override
+     protected final void serverAiStep() {
+-        this.noActionTime++;
++        ++this.noActionTime;
++        if (!this.aware) return; // CraftBukkit
+         this.level().getProfiler().push("sensing");
+         this.sensing.tick();
+         this.level().getProfiler().pop();
+         int i = this.level().getServer().getTickCount() + this.getId();
++
+         if (i % 2 != 0 && this.tickCount > 1) {
+             this.level().getProfiler().push("targetSelector");
+             this.targetSelector.tickRunningGoals(false);
+@@ -753,8 +920,7 @@
+         DebugPackets.sendGoalSelector(this.level(), this, this.goalSelector);
+     }
+ 
+-    protected void customServerAiStep() {
+-    }
++    protected void customServerAiStep() {}
+ 
+     public int getMaxHeadXRot() {
+         return 40;
+@@ -769,41 +935,47 @@
+     }
+ 
+     public void lookAt(Entity entity, float maxYRotIncrease, float maxXRotIncrease) {
+-        double d = entity.getX() - this.getX();
++        double d0 = entity.getX() - this.getX();
+         double d1 = entity.getZ() - this.getZ();
+         double d2;
+-        if (entity instanceof LivingEntity livingEntity) {
+-            d2 = livingEntity.getEyeY() - this.getEyeY();
++
++        if (entity instanceof LivingEntity) {
++            LivingEntity entityliving = (LivingEntity) entity;
++
++            d2 = entityliving.getEyeY() - this.getEyeY();
+         } else {
+-            d2 = (entity.getBoundingBox().minY + entity.getBoundingBox().maxY) / 2.0 - this.getEyeY();
++            d2 = (entity.getBoundingBox().minY + entity.getBoundingBox().maxY) / 2.0D - this.getEyeY();
+         }
+ 
+-        double squareRoot = Math.sqrt(d * d + d1 * d1);
+-        float f = (float)(Mth.atan2(d1, d) * 180.0F / (float)Math.PI) - 90.0F;
+-        float f1 = (float)(-(Mth.atan2(d2, squareRoot) * 180.0F / (float)Math.PI));
+-        this.setXRot(this.rotlerp(this.getXRot(), f1, maxXRotIncrease));
+-        this.setYRot(this.rotlerp(this.getYRot(), f, maxYRotIncrease));
++        double d3 = Math.sqrt(d0 * d0 + d1 * d1);
++        float f2 = (float) (Mth.atan2(d1, d0) * 57.2957763671875D) - 90.0F;
++        float f3 = (float) (-(Mth.atan2(d2, d3) * 57.2957763671875D));
++
++        this.setXRot(this.rotlerp(this.getXRot(), f3, maxXRotIncrease));
++        this.setYRot(this.rotlerp(this.getYRot(), f2, maxYRotIncrease));
+     }
+ 
+     private float rotlerp(float angle, float targetAngle, float maxIncrease) {
+-        float f = Mth.wrapDegrees(targetAngle - angle);
+-        if (f > maxIncrease) {
+-            f = maxIncrease;
++        float f3 = Mth.wrapDegrees(targetAngle - angle);
++
++        if (f3 > maxIncrease) {
++            f3 = maxIncrease;
+         }
+ 
+-        if (f < -maxIncrease) {
+-            f = -maxIncrease;
++        if (f3 < -maxIncrease) {
++            f3 = -maxIncrease;
+         }
+ 
+-        return angle + f;
++        return angle + f3;
+     }
+ 
+-    public static boolean checkMobSpawnRules(EntityType<? extends Mob> type, LevelAccessor level, MobSpawnType spawnType, BlockPos pos, RandomSource random) {
+-        BlockPos blockPos = pos.below();
+-        return spawnType == MobSpawnType.SPAWNER || level.getBlockState(blockPos).isValidSpawn(level, blockPos, type);
++    public static boolean checkMobSpawnRules(EntityType<? extends Mob> type, LevelAccessor level, EnumMobSpawn spawnType, BlockPos pos, RandomSource random) {
++        BlockPos blockposition1 = pos.below();
++
++        return spawnType == EnumMobSpawn.SPAWNER || level.getBlockState(blockposition1).isValidSpawn(level, blockposition1, type);
+     }
+ 
+-    public boolean checkSpawnRules(LevelAccessor level, MobSpawnType reason) {
++    public boolean checkSpawnRules(LevelAccessor level, EnumMobSpawn reason) {
+         return true;
+     }
+ 
+@@ -824,13 +996,14 @@
+         if (this.getTarget() == null) {
+             return 3;
+         } else {
+-            int i = (int)(this.getHealth() - this.getMaxHealth() * 0.33F);
+-            int var2 = i - (3 - this.level().getDifficulty().getId()) * 4;
+-            if (var2 < 0) {
+-                var2 = 0;
++            int i = (int) (this.getHealth() - this.getMaxHealth() * 0.33F);
++
++            i -= (3 - this.level().getDifficulty().getId()) * 4;
++            if (i < 0) {
++                i = 0;
+             }
+ 
+-            return var2 + 3;
++            return i + 3;
+         }
+     }
+ 
+@@ -848,9 +1021,9 @@
+     public ItemStack getItemBySlot(EquipmentSlot slot) {
+         switch (slot.getType()) {
+             case HAND:
+-                return this.handItems.get(slot.getIndex());
++                return (ItemStack) this.handItems.get(slot.getIndex());
+             case ARMOR:
+-                return this.armorItems.get(slot.getIndex());
++                return (ItemStack) this.armorItems.get(slot.getIndex());
+             default:
+                 return ItemStack.EMPTY;
+         }
+@@ -861,80 +1034,98 @@
+         this.verifyEquippedItem(stack);
+         switch (slot.getType()) {
+             case HAND:
+-                this.onEquipItem(slot, this.handItems.set(slot.getIndex(), stack), stack);
++                this.onEquipItem(slot, (ItemStack) this.handItems.set(slot.getIndex(), stack), stack);
+                 break;
+             case ARMOR:
+-                this.onEquipItem(slot, this.armorItems.set(slot.getIndex(), stack), stack);
++                this.onEquipItem(slot, (ItemStack) this.armorItems.set(slot.getIndex(), stack), stack);
+         }
++
+     }
+ 
+     @Override
+     protected void dropCustomDeathLoot(DamageSource source, int looting, boolean recentlyHit) {
+         super.dropCustomDeathLoot(source, looting, recentlyHit);
++        EquipmentSlot[] aenumitemslot = EquipmentSlot.values();
++        int j = aenumitemslot.length;
+ 
+-        for (EquipmentSlot equipmentSlot : EquipmentSlot.values()) {
+-            ItemStack itemBySlot = this.getItemBySlot(equipmentSlot);
+-            float equipmentDropChance = this.getEquipmentDropChance(equipmentSlot);
+-            boolean flag = equipmentDropChance > 1.0F;
+-            if (!itemBySlot.isEmpty()
+-                && !EnchantmentHelper.hasVanishingCurse(itemBySlot)
+-                && (recentlyHit || flag)
+-                && Math.max(this.random.nextFloat() - (float)looting * 0.01F, 0.0F) < equipmentDropChance) {
+-                if (!flag && itemBySlot.isDamageableItem()) {
+-                    itemBySlot.setDamageValue(
+-                        itemBySlot.getMaxDamage() - this.random.nextInt(1 + this.random.nextInt(Math.max(itemBySlot.getMaxDamage() - 3, 1)))
+-                    );
++        for (int k = 0; k < j; ++k) {
++            EquipmentSlot enumitemslot = aenumitemslot[k];
++            ItemStack itemstack = this.getItemBySlot(enumitemslot);
++            float f = this.getEquipmentDropChance(enumitemslot);
++            boolean flag1 = f > 1.0F;
++
++            if (!itemstack.isEmpty() && !EnchantmentHelper.hasVanishingCurse(itemstack) && (recentlyHit || flag1) && Math.max(this.random.nextFloat() - (float) looting * 0.01F, 0.0F) < f) {
++                if (!flag1 && itemstack.isDamageableItem()) {
++                    itemstack.setDamageValue(itemstack.getMaxDamage() - this.random.nextInt(1 + this.random.nextInt(Math.max(itemstack.getMaxDamage() - 3, 1))));
+                 }
+ 
+-                this.spawnAtLocation(itemBySlot);
+-                this.setItemSlot(equipmentSlot, ItemStack.EMPTY);
++                this.spawnAtLocation(itemstack);
++                this.setItemSlot(enumitemslot, ItemStack.EMPTY);
+             }
+         }
++
+     }
+ 
+     protected float getEquipmentDropChance(EquipmentSlot slot) {
+-        return switch (slot.getType()) {
+-            case HAND -> this.handDropChances[slot.getIndex()];
+-            case ARMOR -> this.armorDropChances[slot.getIndex()];
+-            default -> 0.0F;
+-        };
++        float f;
++
++        switch (slot.getType()) {
++            case HAND:
++                f = this.handDropChances[slot.getIndex()];
++                break;
++            case ARMOR:
++                f = this.armorDropChances[slot.getIndex()];
++                break;
++            default:
++                f = 0.0F;
++        }
++
++        return f;
+     }
+ 
+     protected void populateDefaultEquipmentSlots(RandomSource random, DifficultyInstance difficulty) {
+         if (random.nextFloat() < 0.15F * difficulty.getSpecialMultiplier()) {
+-            int randomInt = random.nextInt(2);
++            int i = random.nextInt(2);
+             float f = this.level().getDifficulty() == Difficulty.HARD ? 0.1F : 0.25F;
++
+             if (random.nextFloat() < 0.095F) {
+-                randomInt++;
++                ++i;
+             }
+ 
+             if (random.nextFloat() < 0.095F) {
+-                randomInt++;
++                ++i;
+             }
+ 
+             if (random.nextFloat() < 0.095F) {
+-                randomInt++;
++                ++i;
+             }
+ 
+             boolean flag = true;
++            EquipmentSlot[] aenumitemslot = EquipmentSlot.values();
++            int j = aenumitemslot.length;
+ 
+-            for (EquipmentSlot equipmentSlot : EquipmentSlot.values()) {
+-                if (equipmentSlot.getType() == EquipmentSlot.Type.ARMOR) {
+-                    ItemStack itemBySlot = this.getItemBySlot(equipmentSlot);
++            for (int k = 0; k < j; ++k) {
++                EquipmentSlot enumitemslot = aenumitemslot[k];
++
++                if (enumitemslot.getType() == EquipmentSlot.Function.ARMOR) {
++                    ItemStack itemstack = this.getItemBySlot(enumitemslot);
++
+                     if (!flag && random.nextFloat() < f) {
+                         break;
+                     }
+ 
+                     flag = false;
+-                    if (itemBySlot.isEmpty()) {
+-                        Item equipmentForSlot = getEquipmentForSlot(equipmentSlot, randomInt);
+-                        if (equipmentForSlot != null) {
+-                            this.setItemSlot(equipmentSlot, new ItemStack(equipmentForSlot));
++                    if (itemstack.isEmpty()) {
++                        Item item = getEquipmentForSlot(enumitemslot, i);
++
++                        if (item != null) {
++                            this.setItemSlot(enumitemslot, new ItemStack(item));
+                         }
+                     }
+                 }
+             }
+         }
++
+     }
+ 
+     @Nullable
+@@ -994,42 +1185,44 @@
+     }
+ 
+     protected void populateDefaultEquipmentEnchantments(RandomSource random, DifficultyInstance difficulty) {
+-        float specialMultiplier = difficulty.getSpecialMultiplier();
+-        this.enchantSpawnedWeapon(random, specialMultiplier);
++        float f = difficulty.getSpecialMultiplier();
+ 
+-        for (EquipmentSlot equipmentSlot : EquipmentSlot.values()) {
+-            if (equipmentSlot.getType() == EquipmentSlot.Type.ARMOR) {
+-                this.enchantSpawnedArmor(random, specialMultiplier, equipmentSlot);
++        this.enchantSpawnedWeapon(random, f);
++        EquipmentSlot[] aenumitemslot = EquipmentSlot.values();
++        int i = aenumitemslot.length;
++
++        for (int j = 0; j < i; ++j) {
++            EquipmentSlot enumitemslot = aenumitemslot[j];
++
++            if (enumitemslot.getType() == EquipmentSlot.Function.ARMOR) {
++                this.enchantSpawnedArmor(random, f, enumitemslot);
+             }
+         }
++
+     }
+ 
+     protected void enchantSpawnedWeapon(RandomSource random, float chanceMultiplier) {
+         if (!this.getMainHandItem().isEmpty() && random.nextFloat() < 0.25F * chanceMultiplier) {
+-            this.setItemSlot(
+-                EquipmentSlot.MAINHAND,
+-                EnchantmentHelper.enchantItem(random, this.getMainHandItem(), (int)(5.0F + chanceMultiplier * (float)random.nextInt(18)), false)
+-            );
++            this.setItemSlot(EquipmentSlot.MAINHAND, EnchantmentHelper.enchantItem(random, this.getMainHandItem(), (int) (5.0F + chanceMultiplier * (float) random.nextInt(18)), false));
+         }
++
+     }
+ 
+     protected void enchantSpawnedArmor(RandomSource random, float chanceMultiplier, EquipmentSlot slot) {
+-        ItemStack itemBySlot = this.getItemBySlot(slot);
+-        if (!itemBySlot.isEmpty() && random.nextFloat() < 0.5F * chanceMultiplier) {
+-            this.setItemSlot(slot, EnchantmentHelper.enchantItem(random, itemBySlot, (int)(5.0F + chanceMultiplier * (float)random.nextInt(18)), false));
++        ItemStack itemstack = this.getItemBySlot(slot);
++
++        if (!itemstack.isEmpty() && random.nextFloat() < 0.5F * chanceMultiplier) {
++            this.setItemSlot(slot, EnchantmentHelper.enchantItem(random, itemstack, (int) (5.0F + chanceMultiplier * (float) random.nextInt(18)), false));
+         }
++
+     }
+ 
+     @Nullable
+-    public SpawnGroupData finalizeSpawn(
+-        ServerLevelAccessor level, DifficultyInstance difficulty, MobSpawnType reason, @Nullable SpawnGroupData spawnData, @Nullable CompoundTag dataTag
+-    ) {
+-        RandomSource random = level.getRandom();
+-        this.getAttribute(Attributes.FOLLOW_RANGE)
+-            .addPermanentModifier(
+-                new AttributeModifier("Random spawn bonus", random.triangle(0.0, 0.11485000000000001), AttributeModifier.Operation.MULTIPLY_BASE)
+-            );
+-        if (random.nextFloat() < 0.05F) {
++    public GroupDataEntity finalizeSpawn(ServerLevelAccessor level, DifficultyInstance difficulty, EnumMobSpawn reason, @Nullable GroupDataEntity spawnData, @Nullable CompoundTag dataTag) {
++        RandomSource randomsource = level.getRandom();
++
++        this.getAttribute(Attributes.FOLLOW_RANGE).addPermanentModifier(new AttributeModifier("Random spawn bonus", randomsource.triangle(0.0D, 0.11485000000000001D), AttributeModifier.Operation.MULTIPLY_BASE));
++        if (randomsource.nextFloat() < 0.05F) {
+             this.setLeftHanded(true);
+         } else {
+             this.setLeftHanded(false);
+@@ -1050,6 +1243,7 @@
+             case ARMOR:
+                 this.armorDropChances[slot.getIndex()] = chance;
+         }
++
+     }
+ 
+     public boolean canPickUpLoot() {
+@@ -1062,8 +1256,9 @@
+ 
+     @Override
+     public boolean canTakeItem(ItemStack itemstack) {
+-        EquipmentSlot equipmentSlotForItem = getEquipmentSlotForItem(itemstack);
+-        return this.getItemBySlot(equipmentSlotForItem).isEmpty() && this.canPickUpLoot();
++        EquipmentSlot enumitemslot = getEquipmentSlotForItem(itemstack);
++
++        return this.getItemBySlot(enumitemslot).isEmpty() && this.canPickUpLoot();
+     }
+ 
+     public boolean isPersistenceRequired() {
+@@ -1071,23 +1266,30 @@
+     }
+ 
+     @Override
+-    public final InteractionResult interact(Player player, InteractionHand hand) {
++    public final InteractionResult interact(Player player, EnumHand hand) {
+         if (!this.isAlive()) {
+             return InteractionResult.PASS;
+         } else if (this.getLeashHolder() == player) {
++            // CraftBukkit start - fire PlayerUnleashEntityEvent
++            if (CraftEventFactory.callPlayerUnleashEntityEvent(this, player, hand).isCancelled()) {
++                ((ServerPlayer) player).connection.send(new ClientboundSetEntityLinkPacket(this, this.getLeashHolder()));
++                return InteractionResult.PASS;
++            }
++            // CraftBukkit end
+             this.dropLeash(true, !player.getAbilities().instabuild);
+             this.gameEvent(GameEvent.ENTITY_INTERACT, player);
+             return InteractionResult.sidedSuccess(this.level().isClientSide);
+         } else {
+-            InteractionResult interactionResult = this.checkAndHandleImportantInteractions(player, hand);
+-            if (interactionResult.consumesAction()) {
++            InteractionResult enuminteractionresult = this.checkAndHandleImportantInteractions(player, hand);
++
++            if (enuminteractionresult.consumesAction()) {
+                 this.gameEvent(GameEvent.ENTITY_INTERACT, player);
+-                return interactionResult;
++                return enuminteractionresult;
+             } else {
+-                interactionResult = this.mobInteract(player, hand);
+-                if (interactionResult.consumesAction()) {
++                enuminteractionresult = this.mobInteract(player, hand);
++                if (enuminteractionresult.consumesAction()) {
+                     this.gameEvent(GameEvent.ENTITY_INTERACT, player);
+-                    return interactionResult;
++                    return enuminteractionresult;
+                 } else {
+                     return super.interact(player, hand);
+                 }
+@@ -1095,27 +1297,36 @@
+         }
+     }
+ 
+-    private InteractionResult checkAndHandleImportantInteractions(Player player, InteractionHand hand) {
+-        ItemStack itemInHand = player.getItemInHand(hand);
+-        if (itemInHand.is(Items.LEAD) && this.canBeLeashed(player)) {
++    private InteractionResult checkAndHandleImportantInteractions(Player player, EnumHand hand) {
++        ItemStack itemstack = player.getItemInHand(hand);
++
++        if (itemstack.is(Items.LEAD) && this.canBeLeashed(player)) {
++            // CraftBukkit start - fire PlayerLeashEntityEvent
++            if (CraftEventFactory.callPlayerLeashEntityEvent(this, player, player, hand).isCancelled()) {
++                ((ServerPlayer) player).connection.send(new ClientboundSetEntityLinkPacket(this, this.getLeashHolder()));
++                return InteractionResult.PASS;
++            }
++            // CraftBukkit end
+             this.setLeashedTo(player, true);
+-            itemInHand.shrink(1);
++            itemstack.shrink(1);
+             return InteractionResult.sidedSuccess(this.level().isClientSide);
+         } else {
+-            if (itemInHand.is(Items.NAME_TAG)) {
+-                InteractionResult interactionResult = itemInHand.interactLivingEntity(player, this, hand);
+-                if (interactionResult.consumesAction()) {
+-                    return interactionResult;
++            if (itemstack.is(Items.NAME_TAG)) {
++                InteractionResult enuminteractionresult = itemstack.interactLivingEntity(player, this, hand);
++
++                if (enuminteractionresult.consumesAction()) {
++                    return enuminteractionresult;
+                 }
+             }
+ 
+-            if (itemInHand.getItem() instanceof SpawnEggItem) {
++            if (itemstack.getItem() instanceof SpawnEggItem) {
+                 if (this.level() instanceof ServerLevel) {
+-                    SpawnEggItem spawnEggItem = (SpawnEggItem)itemInHand.getItem();
+-                    Optional<Mob> optional = spawnEggItem.spawnOffspringFromSpawnEgg(
+-                        player, this, (EntityType<? extends Mob>)this.getType(), (ServerLevel)this.level(), this.position(), itemInHand
+-                    );
+-                    optional.ifPresent(mob -> this.onOffspringSpawnedFromEgg(player, mob));
++                    SpawnEggItem itemmonsteregg = (SpawnEggItem) itemstack.getItem();
++                    Optional<Mob> optional = itemmonsteregg.spawnOffspringFromSpawnEgg(player, this, (EntityType<? extends Mob>) this.getType(), (ServerLevel) this.level(), this.position(), itemstack); // CraftBukkit - decompile error
++
++                    optional.ifPresent((entityinsentient) -> {
++                        this.onOffspringSpawnedFromEgg(player, entityinsentient);
++                    });
+                     return optional.isPresent() ? InteractionResult.SUCCESS : InteractionResult.PASS;
+                 } else {
+                     return InteractionResult.CONSUME;
+@@ -1126,10 +1337,9 @@
+         }
+     }
+ 
+-    protected void onOffspringSpawnedFromEgg(Player player, Mob child) {
+-    }
++    protected void onOffspringSpawnedFromEgg(Player player, Mob child) {}
+ 
+-    protected InteractionResult mobInteract(Player player, InteractionHand hand) {
++    protected InteractionResult mobInteract(Player player, EnumHand hand) {
+         return InteractionResult.PASS;
+     }
+ 
+@@ -1138,12 +1348,12 @@
+     }
+ 
+     public boolean isWithinRestriction(BlockPos pos) {
+-        return this.restrictRadius == -1.0F || this.restrictCenter.distSqr(pos) < (double)(this.restrictRadius * this.restrictRadius);
++        return this.restrictRadius == -1.0F ? true : this.restrictCenter.distSqr(pos) < (double) (this.restrictRadius * this.restrictRadius);
+     }
+ 
+     public void restrictTo(BlockPos pos, int distance) {
+         this.restrictCenter = pos;
+-        this.restrictRadius = (float)distance;
++        this.restrictRadius = (float) distance;
+     }
+ 
+     public BlockPos getRestrictCenter() {
+@@ -1162,49 +1372,67 @@
+         return this.restrictRadius != -1.0F;
+     }
+ 
++    // CraftBukkit start
+     @Nullable
+     public <T extends Mob> T convertTo(EntityType<T> entityType, boolean transferInventory) {
++        return this.convertTo(entityType, transferInventory, EntityTransformEvent.TransformReason.UNKNOWN, CreatureSpawnEvent.SpawnReason.DEFAULT);
++    }
++
++    @Nullable
++    public <T extends Mob> T convertTo(EntityType<T> entitytypes, boolean flag, EntityTransformEvent.TransformReason transformReason, CreatureSpawnEvent.SpawnReason spawnReason) {
++        // CraftBukkit end
+         if (this.isRemoved()) {
+             return null;
+         } else {
+-            T mob = (T)entityType.create(this.level());
+-            if (mob == null) {
++            T t0 = entitytypes.create(this.level()); // CraftBukkit - decompile error
++
++            if (t0 == null) {
+                 return null;
+             } else {
+-                mob.copyPosition(this);
+-                mob.setBaby(this.isBaby());
+-                mob.setNoAi(this.isNoAi());
++                t0.copyPosition(this);
++                t0.setBaby(this.isBaby());
++                t0.setNoAi(this.isNoAi());
+                 if (this.hasCustomName()) {
+-                    mob.setCustomName(this.getCustomName());
+-                    mob.setCustomNameVisible(this.isCustomNameVisible());
++                    t0.setCustomName(this.getCustomName());
++                    t0.setCustomNameVisible(this.isCustomNameVisible());
+                 }
+ 
+                 if (this.isPersistenceRequired()) {
+-                    mob.setPersistenceRequired();
++                    t0.setPersistenceRequired();
+                 }
+ 
+-                mob.setInvulnerable(this.isInvulnerable());
+-                if (transferInventory) {
+-                    mob.setCanPickUpLoot(this.canPickUpLoot());
++                t0.setInvulnerable(this.isInvulnerable());
++                if (flag) {
++                    t0.setCanPickUpLoot(this.canPickUpLoot());
++                    EquipmentSlot[] aenumitemslot = EquipmentSlot.values();
++                    int i = aenumitemslot.length;
+ 
+-                    for (EquipmentSlot equipmentSlot : EquipmentSlot.values()) {
+-                        ItemStack itemBySlot = this.getItemBySlot(equipmentSlot);
+-                        if (!itemBySlot.isEmpty()) {
+-                            mob.setItemSlot(equipmentSlot, itemBySlot.copyAndClear());
+-                            mob.setDropChance(equipmentSlot, this.getEquipmentDropChance(equipmentSlot));
++                    for (int j = 0; j < i; ++j) {
++                        EquipmentSlot enumitemslot = aenumitemslot[j];
++                        ItemStack itemstack = this.getItemBySlot(enumitemslot);
++
++                        if (!itemstack.isEmpty()) {
++                            t0.setItemSlot(enumitemslot, itemstack.copyAndClear());
++                            t0.setDropChance(enumitemslot, this.getEquipmentDropChance(enumitemslot));
+                         }
+                     }
+                 }
+ 
+-                this.level().addFreshEntity(mob);
++                // CraftBukkit start
++                if (CraftEventFactory.callEntityTransformEvent(this, t0, transformReason).isCancelled()) {
++                    return null;
++                }
++                this.level().addFreshEntity(t0, spawnReason);
++                // CraftBukkit end
+                 if (this.isPassenger()) {
+-                    Entity vehicle = this.getVehicle();
++                    Entity entity = this.getVehicle();
++
+                     this.stopRiding();
+-                    mob.startRiding(vehicle, true);
++                    t0.startRiding(entity, true);
+                 }
+ 
+                 this.discard();
+-                return mob;
++                return t0;
+             }
+         }
+     }
+@@ -1216,8 +1444,10 @@
+ 
+         if (this.leashHolder != null) {
+             if (!this.isAlive() || !this.leashHolder.isAlive()) {
+-                this.dropLeash(true, true);
++                this.level().getCraftServer().getPluginManager().callEvent(new EntityUnleashEvent(this.getBukkitEntity(), (!this.isAlive()) ? UnleashReason.PLAYER_UNLEASH : UnleashReason.HOLDER_GONE)); // CraftBukkit
++                this.dropLeash(true, !this.leashHolder.pluginRemoved);// CraftBukkit - SPIGOT-7487: Don't drop leash, when the holder was removed by a plugin
+             }
++
+         }
+     }
+ 
+@@ -1226,17 +1456,20 @@
+             this.leashHolder = null;
+             this.leashInfoTag = null;
+             if (!this.level().isClientSide && dropLeash) {
+-                this.spawnAtLocation(Items.LEAD);
++                this.forceDrops = true; // CraftBukkit
++                this.spawnAtLocation((IMaterial) Items.LEAD);
++                this.forceDrops = false; // CraftBukkit
+             }
+ 
+             if (!this.level().isClientSide && broadcastPacket && this.level() instanceof ServerLevel) {
+-                ((ServerLevel)this.level()).getChunkSource().broadcast(this, new ClientboundSetEntityLinkPacket(this, null));
++                ((ServerLevel) this.level()).getChunkSource().broadcast(this, new ClientboundSetEntityLinkPacket(this, (Entity) null));
+             }
+         }
++
+     }
+ 
+     public boolean canBeLeashed(Player player) {
+-        return !this.isLeashed() && !(this instanceof Enemy);
++        return !this.isLeashed() && !(this instanceof IMonster);
+     }
+ 
+     public boolean isLeashed() {
+@@ -1256,12 +1489,13 @@
+         this.leashHolder = leashHolder;
+         this.leashInfoTag = null;
+         if (!this.level().isClientSide && broadcastPacket && this.level() instanceof ServerLevel) {
+-            ((ServerLevel)this.level()).getChunkSource().broadcast(this, new ClientboundSetEntityLinkPacket(this, this.leashHolder));
++            ((ServerLevel) this.level()).getChunkSource().broadcast(this, new ClientboundSetEntityLinkPacket(this, this.leashHolder));
+         }
+ 
+         if (this.isPassenger()) {
+             this.stopRiding();
+         }
++
+     }
+ 
+     public void setDelayedLeashHolderId(int leashHolderID) {
+@@ -1271,34 +1505,41 @@
+ 
+     @Override
+     public boolean startRiding(Entity entity, boolean force) {
+-        boolean flag = super.startRiding(entity, force);
+-        if (flag && this.isLeashed()) {
++        boolean flag1 = super.startRiding(entity, force);
++
++        if (flag1 && this.isLeashed()) {
++            this.level().getCraftServer().getPluginManager().callEvent(new EntityUnleashEvent(this.getBukkitEntity(), UnleashReason.UNKNOWN)); // CraftBukkit
+             this.dropLeash(true, true);
+         }
+ 
+-        return flag;
++        return flag1;
+     }
+ 
+     private void restoreLeashFromSave() {
+         if (this.leashInfoTag != null && this.level() instanceof ServerLevel) {
+             if (this.leashInfoTag.hasUUID("UUID")) {
+-                UUID uUID = this.leashInfoTag.getUUID("UUID");
+-                Entity entity = ((ServerLevel)this.level()).getEntity(uUID);
++                UUID uuid = this.leashInfoTag.getUUID("UUID");
++                Entity entity = ((ServerLevel) this.level()).getEntity(uuid);
++
+                 if (entity != null) {
+                     this.setLeashedTo(entity, true);
+                     return;
+                 }
+             } else if (this.leashInfoTag.contains("X", 99) && this.leashInfoTag.contains("Y", 99) && this.leashInfoTag.contains("Z", 99)) {
+-                BlockPos blockPos = NbtUtils.readBlockPos(this.leashInfoTag);
+-                this.setLeashedTo(LeashFenceKnotEntity.getOrCreateKnot(this.level(), blockPos), true);
++                BlockPos blockposition = NbtUtils.readBlockPos(this.leashInfoTag);
++
++                this.setLeashedTo(LeashFenceKnotEntity.getOrCreateKnot(this.level(), blockposition), true);
+                 return;
+             }
+ 
+             if (this.tickCount > 100) {
+-                this.spawnAtLocation(Items.LEAD);
++                this.forceDrops = true; // CraftBukkit
++                this.spawnAtLocation((IMaterial) Items.LEAD);
++                this.forceDrops = false; // CraftBukkit
+                 this.leashInfoTag = null;
+             }
+         }
++
+     }
+ 
+     @Override
+@@ -1307,34 +1548,36 @@
+     }
+ 
+     public void setNoAi(boolean noAi) {
+-        byte b = this.entityData.get(DATA_MOB_FLAGS_ID);
+-        this.entityData.set(DATA_MOB_FLAGS_ID, noAi ? (byte)(b | 1) : (byte)(b & -2));
++        byte b0 = (Byte) this.entityData.get(Mob.DATA_MOB_FLAGS_ID);
++
++        this.entityData.set(Mob.DATA_MOB_FLAGS_ID, noAi ? (byte) (b0 | 1) : (byte) (b0 & -2));
+     }
+ 
+     public void setLeftHanded(boolean leftHanded) {
+-        byte b = this.entityData.get(DATA_MOB_FLAGS_ID);
+-        this.entityData.set(DATA_MOB_FLAGS_ID, leftHanded ? (byte)(b | 2) : (byte)(b & -3));
++        byte b0 = (Byte) this.entityData.get(Mob.DATA_MOB_FLAGS_ID);
++
++        this.entityData.set(Mob.DATA_MOB_FLAGS_ID, leftHanded ? (byte) (b0 | 2) : (byte) (b0 & -3));
+     }
+ 
+     public void setAggressive(boolean aggressive) {
+-        byte b = this.entityData.get(DATA_MOB_FLAGS_ID);
+-        this.entityData.set(DATA_MOB_FLAGS_ID, aggressive ? (byte)(b | 4) : (byte)(b & -5));
++        byte b0 = (Byte) this.entityData.get(Mob.DATA_MOB_FLAGS_ID);
++
++        this.entityData.set(Mob.DATA_MOB_FLAGS_ID, aggressive ? (byte) (b0 | 4) : (byte) (b0 & -5));
+     }
+ 
+     public boolean isNoAi() {
+-        return (this.entityData.get(DATA_MOB_FLAGS_ID) & 1) != 0;
++        return ((Byte) this.entityData.get(Mob.DATA_MOB_FLAGS_ID) & 1) != 0;
+     }
+ 
+     public boolean isLeftHanded() {
+-        return (this.entityData.get(DATA_MOB_FLAGS_ID) & 2) != 0;
++        return ((Byte) this.entityData.get(Mob.DATA_MOB_FLAGS_ID) & 2) != 0;
+     }
+ 
+     public boolean isAggressive() {
+-        return (this.entityData.get(DATA_MOB_FLAGS_ID) & 4) != 0;
++        return ((Byte) this.entityData.get(Mob.DATA_MOB_FLAGS_ID) & 4) != 0;
+     }
+ 
+-    public void setBaby(boolean baby) {
+-    }
++    public void setBaby(boolean baby) {}
+ 
+     @Override
+     public HumanoidArm getMainArm() {
+@@ -1346,54 +1589,56 @@
+     }
+ 
+     protected AABB getAttackBoundingBox() {
+-        Entity vehicle = this.getVehicle();
+-        AABB aABB;
+-        if (vehicle != null) {
+-            AABB boundingBox = vehicle.getBoundingBox();
+-            AABB boundingBox1 = this.getBoundingBox();
+-            aABB = new AABB(
+-                Math.min(boundingBox1.minX, boundingBox.minX),
+-                boundingBox1.minY,
+-                Math.min(boundingBox1.minZ, boundingBox.minZ),
+-                Math.max(boundingBox1.maxX, boundingBox.maxX),
+-                boundingBox1.maxY,
+-                Math.max(boundingBox1.maxZ, boundingBox.maxZ)
+-            );
++        Entity entity = this.getVehicle();
++        AABB axisalignedbb;
++
++        if (entity != null) {
++            AABB axisalignedbb1 = entity.getBoundingBox();
++            AABB axisalignedbb2 = this.getBoundingBox();
++
++            axisalignedbb = new AABB(Math.min(axisalignedbb2.minX, axisalignedbb1.minX), axisalignedbb2.minY, Math.min(axisalignedbb2.minZ, axisalignedbb1.minZ), Math.max(axisalignedbb2.maxX, axisalignedbb1.maxX), axisalignedbb2.maxY, Math.max(axisalignedbb2.maxZ, axisalignedbb1.maxZ));
+         } else {
+-            aABB = this.getBoundingBox();
++            axisalignedbb = this.getBoundingBox();
+         }
+ 
+-        return aABB.inflate(DEFAULT_ATTACK_REACH, 0.0, DEFAULT_ATTACK_REACH);
++        return axisalignedbb.inflate(Mob.DEFAULT_ATTACK_REACH, 0.0D, Mob.DEFAULT_ATTACK_REACH);
+     }
+ 
+     @Override
+     public boolean doHurtTarget(Entity entity) {
+-        float f = (float)this.getAttributeValue(Attributes.ATTACK_DAMAGE);
+-        float f1 = (float)this.getAttributeValue(Attributes.ATTACK_KNOCKBACK);
++        float f = (float) this.getAttributeValue(Attributes.ATTACK_DAMAGE);
++        float f1 = (float) this.getAttributeValue(Attributes.ATTACK_KNOCKBACK);
++
+         if (entity instanceof LivingEntity) {
+-            f += EnchantmentHelper.getDamageBonus(this.getMainHandItem(), ((LivingEntity)entity).getMobType());
+-            f1 += (float)EnchantmentHelper.getKnockbackBonus(this);
++            f += EnchantmentHelper.getDamageBonus(this.getMainHandItem(), ((LivingEntity) entity).getMobType());
++            f1 += (float) EnchantmentHelper.getKnockbackBonus(this);
+         }
+ 
+-        int fireAspect = EnchantmentHelper.getFireAspect(this);
+-        if (fireAspect > 0) {
+-            entity.setSecondsOnFire(fireAspect * 4);
++        int i = EnchantmentHelper.getFireAspect(this);
++
++        if (i > 0) {
++            // CraftBukkit start - Call a combust event when somebody hits with a fire enchanted item
++            EntityCombustByEntityEvent combustEvent = new EntityCombustByEntityEvent(this.getBukkitEntity(), entity.getBukkitEntity(), i * 4);
++            org.bukkit.Bukkit.getPluginManager().callEvent(combustEvent);
++
++            if (!combustEvent.isCancelled()) {
++                entity.setSecondsOnFire(combustEvent.getDuration(), false);
++            }
++            // CraftBukkit end
+         }
+ 
+         boolean flag = entity.hurt(this.damageSources().mobAttack(this), f);
++
+         if (flag) {
+             if (f1 > 0.0F && entity instanceof LivingEntity) {
+-                ((LivingEntity)entity)
+-                    .knockback(
+-                        (double)(f1 * 0.5F),
+-                        (double)Mth.sin(this.getYRot() * (float) (Math.PI / 180.0)),
+-                        (double)(-Mth.cos(this.getYRot() * (float) (Math.PI / 180.0)))
+-                    );
+-                this.setDeltaMovement(this.getDeltaMovement().multiply(0.6, 1.0, 0.6));
++                ((LivingEntity) entity).knockback((double) (f1 * 0.5F), (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)));
++                this.setDeltaMovement(this.getDeltaMovement().multiply(0.6D, 1.0D, 0.6D));
+             }
+ 
+-            if (entity instanceof Player player) {
+-                this.maybeDisableShield(player, this.getMainHandItem(), player.isUsingItem() ? player.getUseItem() : ItemStack.EMPTY);
++            if (entity instanceof Player) {
++                Player entityhuman = (Player) entity;
++
++                this.maybeDisableShield(entityhuman, this.getMainHandItem(), entityhuman.isUsingItem() ? entityhuman.getUseItem() : ItemStack.EMPTY);
+             }
+ 
+             this.doEnchantDamageEffects(this, entity);
+@@ -1405,23 +1650,23 @@
+ 
+     private void maybeDisableShield(Player player, ItemStack mobItemStack, ItemStack playerItemStack) {
+         if (!mobItemStack.isEmpty() && !playerItemStack.isEmpty() && mobItemStack.getItem() instanceof AxeItem && playerItemStack.is(Items.SHIELD)) {
+-            float f = 0.25F + (float)EnchantmentHelper.getBlockEfficiency(this) * 0.05F;
++            float f = 0.25F + (float) EnchantmentHelper.getBlockEfficiency(this) * 0.05F;
++
+             if (this.random.nextFloat() < f) {
+                 player.getCooldowns().addCooldown(Items.SHIELD, 100);
+-                this.level().broadcastEntityEvent(player, (byte)30);
++                this.level().broadcastEntityEvent(player, (byte) 30);
+             }
+         }
++
+     }
+ 
+     protected boolean isSunBurnTick() {
+         if (this.level().isDay() && !this.level().isClientSide) {
+-            float lightLevelDependentMagicValue = this.getLightLevelDependentMagicValue();
+-            BlockPos blockPos = BlockPos.containing(this.getX(), this.getEyeY(), this.getZ());
++            float f = this.getLightLevelDependentMagicValue();
++            BlockPos blockposition = BlockPos.containing(this.getX(), this.getEyeY(), this.getZ());
+             boolean flag = this.isInWaterRainOrBubble() || this.isInPowderSnow || this.wasInPowderSnow;
+-            if (lightLevelDependentMagicValue > 0.5F
+-                && this.random.nextFloat() * 30.0F < (lightLevelDependentMagicValue - 0.4F) * 2.0F
+-                && !flag
+-                && this.level().canSeeSky(blockPos)) {
++
++            if (f > 0.5F && this.random.nextFloat() * 30.0F < (f - 0.4F) * 2.0F && !flag && this.level().canSeeSky(blockposition)) {
+                 return true;
+             }
+         }
+@@ -1434,13 +1679,16 @@
+         if (this.getNavigation().canFloat()) {
+             super.jumpInLiquid(fluidTag);
+         } else {
+-            this.setDeltaMovement(this.getDeltaMovement().add(0.0, 0.3, 0.0));
++            this.setDeltaMovement(this.getDeltaMovement().add(0.0D, 0.3D, 0.0D));
+         }
++
+     }
+ 
+     @VisibleForTesting
+     public void removeFreeWill() {
+-        this.removeAllGoals(goal -> true);
++        this.removeAllGoals((pathfindergoal) -> {
++            return true;
++        });
+         this.getBrain().removeAllBehaviors();
+     }
+ 
+@@ -1451,18 +1699,21 @@
+     @Override
+     protected void removeAfterChangingDimensions() {
+         super.removeAfterChangingDimensions();
++        this.level().getCraftServer().getPluginManager().callEvent(new EntityUnleashEvent(this.getBukkitEntity(), UnleashReason.UNKNOWN)); // CraftBukkit
+         this.dropLeash(true, false);
+-        this.getAllSlots().forEach(slot -> {
+-            if (!slot.isEmpty()) {
+-                slot.setCount(0);
++        this.getAllSlots().forEach((itemstack) -> {
++            if (!itemstack.isEmpty()) {
++                itemstack.setCount(0);
+             }
++
+         });
+     }
+ 
+     @Nullable
+     @Override
+     public ItemStack getPickResult() {
+-        SpawnEggItem spawnEggItem = SpawnEggItem.byId(this.getType());
+-        return spawnEggItem == null ? null : new ItemStack(spawnEggItem);
++        SpawnEggItem itemmonsteregg = SpawnEggItem.byId(this.getType());
++
++        return itemmonsteregg == null ? null : new ItemStack(itemmonsteregg);
+     }
+ }