add remapped patches as a testsoftspoon

1 files changed, 1002 insertions, 0 deletions

diff --git a/patch-remap/mache-spigotflower-stripped/net/minecraft/world/entity/Entity.java.patch b/patch-remap/mache-spigotflower-stripped/net/minecraft/world/entity/Entity.java.patch
new file mode 100644
index 0000000000..952a26da6e
--- /dev/null
+++ b/patch-remap/mache-spigotflower-stripped/net/minecraft/world/entity/Entity.java.patch
@@ -0,0 +1,1002 @@
+--- a/net/minecraft/world/entity/Entity.java
++++ b/net/minecraft/world/entity/Entity.java
+@@ -125,9 +126,63 @@
+ import net.minecraft.world.scores.Team;
+ import org.joml.Vector3f;
+ import org.slf4j.Logger;
++import org.bukkit.Bukkit;
++import org.bukkit.Location;
++import org.bukkit.Server;
++import org.bukkit.block.BlockFace;
++import org.bukkit.command.CommandSender;
++import org.bukkit.craftbukkit.event.CraftPortalEvent;
++import org.bukkit.entity.Hanging;
++import org.bukkit.entity.LivingEntity;
++import org.bukkit.entity.Vehicle;
++import org.bukkit.event.entity.EntityCombustByEntityEvent;
++import org.bukkit.event.hanging.HangingBreakByEntityEvent;
++import org.bukkit.event.vehicle.VehicleBlockCollisionEvent;
++import org.bukkit.event.vehicle.VehicleEnterEvent;
++import org.bukkit.event.vehicle.VehicleExitEvent;
++import org.bukkit.craftbukkit.CraftWorld;
++import org.bukkit.craftbukkit.entity.CraftEntity;
++import org.bukkit.craftbukkit.entity.CraftPlayer;
++import org.bukkit.craftbukkit.event.CraftEventFactory;
++import org.bukkit.craftbukkit.util.CraftLocation;
++import org.bukkit.entity.Pose;
++import org.bukkit.event.entity.EntityAirChangeEvent;
++import org.bukkit.event.entity.EntityCombustEvent;
++import org.bukkit.event.entity.EntityDropItemEvent;
++import org.bukkit.event.entity.EntityPortalEvent;
++import org.bukkit.event.entity.EntityPoseChangeEvent;
++import org.bukkit.event.player.PlayerTeleportEvent;
++import org.bukkit.plugin.PluginManager;
++// CraftBukkit end
+ 
+ public abstract class Entity implements Nameable, EntityAccess, CommandSource, ScoreHolder {
+ 
++    // CraftBukkit start
++    private static final int CURRENT_LEVEL = 2;
++    static boolean isLevelAtLeast(CompoundTag tag, int level) {
++        return tag.contains("Bukkit.updateLevel") && tag.getInt("Bukkit.updateLevel") >= level;
++    }
++
++    private CraftEntity bukkitEntity;
++
++    public CraftEntity getBukkitEntity() {
++        if (bukkitEntity == null) {
++            bukkitEntity = CraftEntity.getEntity(level.getCraftServer(), this);
++        }
++        return bukkitEntity;
++    }
++
++    @Override
++    public CommandSender getBukkitSender(CommandSourceStack wrapper) {
++        return getBukkitEntity();
++    }
++
++    // CraftBukkit - SPIGOT-6907: re-implement LivingEntity#setMaximumAir()
++    public int getDefaultMaxAirSupply() {
++        return TOTAL_AIR_SUPPLY;
++    }
++    // CraftBukkit end
++
+     private static final Logger LOGGER = LogUtils.getLogger();
+     public static final String ID_TAG = "id";
+     public static final String PASSENGERS_TAG = "Passengers";
+@@ -241,9 +296,32 @@
+     private int lastCrystalSoundPlayTick;
+     private boolean hasVisualFire;
+     @Nullable
+-    private BlockState feetBlockState;
++    private IBlockData feetBlockState;
++    // CraftBukkit start
++    public boolean persist = true;
++    public boolean visibleByDefault = true;
++    public boolean valid;
++    public boolean inWorld = false;
++    public boolean generation;
++    public int maxAirTicks = getDefaultMaxAirSupply(); // CraftBukkit - SPIGOT-6907: re-implement LivingEntity#setMaximumAir()
++    public org.bukkit.projectiles.ProjectileSource projectileSource; // For projectiles only
++    public boolean lastDamageCancelled; // SPIGOT-5339, SPIGOT-6252, SPIGOT-6777: Keep track if the event was canceled
++    public boolean persistentInvisibility = false;
++    public BlockPos lastLavaContact;
++    // Marks an entity, that it was removed by a plugin via Entity#remove
++    // Main use case currently is for SPIGOT-7487, preventing dropping of leash when leash is removed
++    public boolean pluginRemoved = false;
+ 
+-    public Entity(EntityType<?> entitytype, Level level) {
++    public float getBukkitYaw() {
++        return this.yRot;
++    }
++
++    public boolean isChunkLoaded() {
++        return level.hasChunk((int) Math.floor(this.getX()) >> 4, (int) Math.floor(this.getZ()) >> 4);
++    }
++    // CraftBukkit end
++
++    public Entity(EntityType<?> entityType, Level level) {
+         this.id = Entity.ENTITY_COUNTER.incrementAndGet();
+         this.passengers = ImmutableList.of();
+         this.deltaMovement = Vec3.ZERO;
+@@ -377,7 +452,13 @@
+ 
+     public void onClientRemoval() {}
+ 
+-    public void setPose(Pose pose) {
++    public void setPose(EntityPose pose) {
++        // CraftBukkit start
++        if (pose == this.getPose()) {
++            return;
++        }
++        this.level.getCraftServer().getPluginManager().callEvent(new EntityPoseChangeEvent(this.getBukkitEntity(), Pose.values()[pose.ordinal()]));
++        // CraftBukkit end
+         this.entityData.set(Entity.DATA_POSE, pose);
+     }
+ 
+@@ -401,9 +482,36 @@
+         return Mth.lengthSquared(d2, d4) < Mth.square(d0) && Mth.square(d3) < Mth.square(d1);
+     }
+ 
+-    protected void setRot(float f, float f1) {
+-        this.setYRot(f % 360.0F);
+-        this.setXRot(f1 % 360.0F);
++    protected void setRot(float yRot, float xRot) {
++        // CraftBukkit start - yaw was sometimes set to NaN, so we need to set it back to 0
++        if (Float.isNaN(yRot)) {
++            yRot = 0;
++        }
++
++        if (yRot == Float.POSITIVE_INFINITY || yRot == Float.NEGATIVE_INFINITY) {
++            if (this instanceof ServerPlayer) {
++                this.level.getCraftServer().getLogger().warning(this.getScoreboardName() + " was caught trying to crash the server with an invalid yaw");
++                ((CraftPlayer) this.getBukkitEntity()).kickPlayer("Infinite yaw (Hacking?)");
++            }
++            yRot = 0;
++        }
++
++        // pitch was sometimes set to NaN, so we need to set it back to 0
++        if (Float.isNaN(xRot)) {
++            xRot = 0;
++        }
++
++        if (xRot == Float.POSITIVE_INFINITY || xRot == Float.NEGATIVE_INFINITY) {
++            if (this instanceof ServerPlayer) {
++                this.level.getCraftServer().getLogger().warning(this.getScoreboardName() + " was caught trying to crash the server with an invalid pitch");
++                ((CraftPlayer) this.getBukkitEntity()).kickPlayer("Infinite pitch (Hacking?)");
++            }
++            xRot = 0;
++        }
++        // CraftBukkit end
++
++        this.setYRot(yRot % 360.0F);
++        this.setXRot(xRot % 360.0F);
+     }
+ 
+     public final void setPos(Vec3 vec3) {
+@@ -443,6 +551,15 @@
+         this.baseTick();
+     }
+ 
++    // CraftBukkit start
++    public void postTick() {
++        // No clean way to break out of ticking once the entity has been copied to a new world, so instead we move the portalling later in the tick cycle
++        if (!(this instanceof ServerPlayer)) {
++            this.handleNetherPortal();
++        }
++    }
++    // CraftBukkit end
++
+     public void baseTick() {
+         this.level().getProfiler().push("entityBaseTick");
+         this.feetBlockState = null;
+@@ -457,7 +574,7 @@
+         this.walkDistO = this.walkDist;
+         this.xRotO = this.getXRot();
+         this.yRotO = this.getYRot();
+-        this.handleNetherPortal();
++        if (this instanceof ServerPlayer) this.handleNetherPortal(); // CraftBukkit - // Moved up to postTick
+         if (this.canSpawnSprintParticle()) {
+             this.spawnSprintParticle();
+         }
+@@ -492,6 +609,10 @@
+         if (this.isInLava()) {
+             this.lavaHurt();
+             this.fallDistance *= 0.5F;
++            // CraftBukkit start
++        } else {
++            this.lastLavaContact = null;
++            // CraftBukkit end
+         }
+ 
+         this.checkBelowWorld();
+@@ -543,15 +664,48 @@
+ 
+     public void lavaHurt() {
+         if (!this.fireImmune()) {
+-            this.setSecondsOnFire(15);
++            // CraftBukkit start - Fallen in lava TODO: this event spams!
++            if (this instanceof net.minecraft.world.entity.LivingEntity && remainingFireTicks <= 0) {
++                // not on fire yet
++                org.bukkit.block.Block damager = (lastLavaContact == null) ? null : org.bukkit.craftbukkit.block.CraftBlock.at(level, lastLavaContact);
++                org.bukkit.entity.Entity damagee = this.getBukkitEntity();
++                EntityCombustEvent combustEvent = new org.bukkit.event.entity.EntityCombustByBlockEvent(damager, damagee, 15);
++                this.level.getCraftServer().getPluginManager().callEvent(combustEvent);
++
++                if (!combustEvent.isCancelled()) {
++                    this.setSecondsOnFire(combustEvent.getDuration(), false);
++                }
++            } else {
++                // This will be called every single tick the entity is in lava, so don't throw an event
++                this.setSecondsOnFire(15, false);
++            }
++            CraftEventFactory.blockDamage = (lastLavaContact) == null ? null : org.bukkit.craftbukkit.block.CraftBlock.at(level, lastLavaContact);
+             if (this.hurt(this.damageSources().lava(), 4.0F)) {
+                 this.playSound(SoundEvents.GENERIC_BURN, 0.4F, 2.0F + this.random.nextFloat() * 0.4F);
+             }
++            CraftEventFactory.blockDamage = null;
++            // CraftBukkit end - we also don't throw an event unless the object in lava is living, to save on some event calls
+ 
+         }
+     }
+ 
+-    public void setSecondsOnFire(int i) {
++    public void setSecondsOnFire(int seconds) {
++        // CraftBukkit start
++        this.setSecondsOnFire(seconds, true);
++    }
++
++    public void setSecondsOnFire(int i, boolean callEvent) {
++        if (callEvent) {
++            EntityCombustEvent event = new EntityCombustEvent(this.getBukkitEntity(), i);
++            this.level.getCraftServer().getPluginManager().callEvent(event);
++
++            if (event.isCancelled()) {
++                return;
++            }
++
++            i = event.getDuration();
++        }
++        // CraftBukkit end
+         int j = i * 20;
+ 
+         if (this instanceof LivingEntity) {
+@@ -702,6 +856,28 @@
+                     block.updateEntityAfterFallOn(this.level(), this);
+                 }
+ 
++                // CraftBukkit start
++                if (horizontalCollision && getBukkitEntity() instanceof Vehicle) {
++                    Vehicle vehicle = (Vehicle) this.getBukkitEntity();
++                    org.bukkit.block.Block bl = this.level.getWorld().getBlockAt(Mth.floor(this.getX()), Mth.floor(this.getY()), Mth.floor(this.getZ()));
++
++                    if (pos.x > vec3d1.x) {
++                        bl = bl.getRelative(BlockFace.EAST);
++                    } else if (pos.x < vec3d1.x) {
++                        bl = bl.getRelative(BlockFace.WEST);
++                    } else if (pos.z > vec3d1.z) {
++                        bl = bl.getRelative(BlockFace.SOUTH);
++                    } else if (pos.z < vec3d1.z) {
++                        bl = bl.getRelative(BlockFace.NORTH);
++                    }
++
++                    if (!bl.getType().isAir()) {
++                        VehicleBlockCollisionEvent event = new VehicleBlockCollisionEvent(vehicle, bl);
++                        level.getCraftServer().getPluginManager().callEvent(event);
++                    }
++                }
++                // CraftBukkit end
++
+                 if (this.onGround()) {
+                     block.stepOn(this.level(), blockpos, blockstate, this);
+                 }
+@@ -1029,6 +1205,20 @@
+         return SoundEvents.GENERIC_SPLASH;
+     }
+ 
++    // CraftBukkit start - Add delegate methods
++    public SoundEvent getSwimSound0() {
++        return getSwimSound();
++    }
++
++    public SoundEvent getSwimSplashSound0() {
++        return getSwimSplashSound();
++    }
++
++    public SoundEvent getSwimHighSpeedSplashSound0() {
++        return getSwimHighSpeedSplashSound();
++    }
++    // CraftBukkit end
++
+     protected void checkInsideBlocks() {
+         AABB aabb = this.getBoundingBox();
+         BlockPos blockpos = BlockPos.containing(aabb.minX + 1.0E-7D, aabb.minY + 1.0E-7D, aabb.minZ + 1.0E-7D);
+@@ -1443,6 +1633,7 @@
+         this.yo = d1;
+         this.zo = d4;
+         this.setPos(d3, d1, d4);
++        if (valid) level.getChunk((int) Math.floor(this.getX()) >> 4, (int) Math.floor(this.getZ()) >> 4); // CraftBukkit
+     }
+ 
+     public void moveTo(Vec3 vec3) {
+@@ -1637,9 +1828,15 @@
+         return false;
+     }
+ 
+-    public void awardKillScore(Entity entity, int i, DamageSource damagesource) {
+-        if (entity instanceof ServerPlayer) {
+-            CriteriaTriggers.ENTITY_KILLED_PLAYER.trigger((ServerPlayer) entity, this, damagesource);
++    // CraftBukkit start - collidable API
++    public boolean canCollideWithBukkit(Entity entity) {
++        return isPushable();
++    }
++    // CraftBukkit end
++
++    public void awardKillScore(Entity killed, int scoreValue, DamageSource source) {
++        if (killed instanceof ServerPlayer) {
++            CriteriaTriggers.ENTITY_KILLED_PLAYER.trigger((ServerPlayer) killed, this, source);
+         }
+ 
+     }
+@@ -1664,17 +1861,23 @@
+         return d0 < d1 * d1;
+     }
+ 
+-    public boolean saveAsPassenger(CompoundTag compoundtag) {
++    public boolean saveAsPassenger(CompoundTag compound) {
++        // CraftBukkit start - allow excluding certain data when saving
++        return saveAsPassenger(compound, true);
++    }
++
++    public boolean saveAsPassenger(CompoundTag nbttagcompound, boolean includeAll) {
++        // CraftBukkit end
+         if (this.removalReason != null && !this.removalReason.shouldSave()) {
+             return false;
+         } else {
+             String s = this.getEncodeId();
+ 
+-            if (s == null) {
++            if (!this.persist || s == null) { // CraftBukkit - persist flag
+                 return false;
+             } else {
+-                compoundtag.putString("id", s);
+-                this.saveWithoutId(compoundtag);
++                nbttagcompound.putString("id", s);
++                this.saveWithoutId(nbttagcompound, includeAll); // CraftBukkit - pass on includeAll
+                 return true;
+             }
+         }
+@@ -1684,13 +1887,23 @@
+         return this.isPassenger() ? false : this.saveAsPassenger(compoundtag);
+     }
+ 
+-    public CompoundTag saveWithoutId(CompoundTag compoundtag) {
++    public CompoundTag saveWithoutId(CompoundTag compound) {
++        // CraftBukkit start - allow excluding certain data when saving
++        return saveWithoutId(compound, true);
++    }
++
++    public CompoundTag saveWithoutId(CompoundTag nbttagcompound, boolean includeAll) {
++        // CraftBukkit end
+         try {
+-            if (this.vehicle != null) {
+-                compoundtag.put("Pos", this.newDoubleList(this.vehicle.getX(), this.getY(), this.vehicle.getZ()));
+-            } else {
+-                compoundtag.put("Pos", this.newDoubleList(this.getX(), this.getY(), this.getZ()));
++            // CraftBukkit start - selectively save position
++            if (includeAll) {
++                if (this.vehicle != null) {
++                    nbttagcompound.put("Pos", this.newDoubleList(this.vehicle.getX(), this.getY(), this.vehicle.getZ()));
++                } else {
++                    nbttagcompound.put("Pos", this.newDoubleList(this.getX(), this.getY(), this.getZ()));
++                }
+             }
++            // CraftBukkit end
+ 
+             Vec3 vec3 = this.getDeltaMovement();
+ 
+@@ -1705,10 +1909,52 @@
+             compoundtag.putUUID("UUID", this.getUUID());
+             Component component = this.getCustomName();
+ 
+-            if (component != null) {
+-                compoundtag.putString("CustomName", Component.Serializer.toJson(component));
++            // CraftBukkit start - Checking for NaN pitch/yaw and resetting to zero
++            // TODO: make sure this is the best way to address this.
++            if (Float.isNaN(this.yRot)) {
++                this.yRot = 0;
+             }
+ 
++            if (Float.isNaN(this.xRot)) {
++                this.xRot = 0;
++            }
++            // CraftBukkit end
++
++            nbttagcompound.put("Rotation", this.newFloatList(this.getYRot(), this.getXRot()));
++            nbttagcompound.putFloat("FallDistance", this.fallDistance);
++            nbttagcompound.putShort("Fire", (short) this.remainingFireTicks);
++            nbttagcompound.putShort("Air", (short) this.getAirSupply());
++            nbttagcompound.putBoolean("OnGround", this.onGround());
++            nbttagcompound.putBoolean("Invulnerable", this.invulnerable);
++            nbttagcompound.putInt("PortalCooldown", this.portalCooldown);
++            // CraftBukkit start - selectively save uuid and world
++            if (includeAll) {
++                nbttagcompound.putUUID("UUID", this.getUUID());
++                // PAIL: Check above UUID reads 1.8 properly, ie: UUIDMost / UUIDLeast
++                nbttagcompound.putLong("WorldUUIDLeast", ((ServerLevel) this.level).getWorld().getUID().getLeastSignificantBits());
++                nbttagcompound.putLong("WorldUUIDMost", ((ServerLevel) this.level).getWorld().getUID().getMostSignificantBits());
++            }
++            nbttagcompound.putInt("Bukkit.updateLevel", CURRENT_LEVEL);
++            if (!this.persist) {
++                nbttagcompound.putBoolean("Bukkit.persist", this.persist);
++            }
++            if (!this.visibleByDefault) {
++                nbttagcompound.putBoolean("Bukkit.visibleByDefault", this.visibleByDefault);
++            }
++            if (this.persistentInvisibility) {
++                nbttagcompound.putBoolean("Bukkit.invisible", this.persistentInvisibility);
++            }
++            // SPIGOT-6907: re-implement LivingEntity#setMaximumAir()
++            if (maxAirTicks != getDefaultMaxAirSupply()) {
++                nbttagcompound.putInt("Bukkit.MaxAirSupply", getMaxAirSupply());
++            }
++            // CraftBukkit end
++            Component ichatbasecomponent = this.getCustomName();
++
++            if (ichatbasecomponent != null) {
++                nbttagcompound.putString("CustomName", Component.Serializer.toJson(ichatbasecomponent));
++            }
++
+             if (this.isCustomNameVisible()) {
+                 compoundtag.putBoolean("CustomNameVisible", this.isCustomNameVisible());
+             }
+@@ -1751,7 +1997,7 @@
+                 compoundtag.put("Tags", listtag);
+             }
+ 
+-            this.addAdditionalSaveData(compoundtag);
++            this.addAdditionalSaveData(nbttagcompound, includeAll); // CraftBukkit - pass on includeAll
+             if (this.isVehicle()) {
+                 listtag = new ListTag();
+                 iterator = this.getPassengers().iterator();
+@@ -1760,8 +2006,8 @@
+                     Entity entity = (Entity) iterator.next();
+                     CompoundTag compoundtag1 = new CompoundTag();
+ 
+-                    if (entity.saveAsPassenger(compoundtag1)) {
+-                        listtag.add(compoundtag1);
++                    if (entity.saveAsPassenger(nbttagcompound1, includeAll)) { // CraftBukkit - pass on includeAll
++                        nbttaglist.add(nbttagcompound1);
+                     }
+                 }
+ 
+@@ -1770,7 +2016,12 @@
+                 }
+             }
+ 
+-            return compoundtag;
++            // CraftBukkit start - stores eventually existing bukkit values
++            if (this.bukkitEntity != null) {
++                this.bukkitEntity.storeBukkitValues(nbttagcompound);
++            }
++            // CraftBukkit end
++            return nbttagcompound;
+         } catch (Throwable throwable) {
+             CrashReport crashreport = CrashReport.forThrowable(throwable, "Saving entity NBT");
+             CrashReportCategory crashreportcategory = crashreport.addCategory("Entity being saved");
+@@ -1853,6 +2104,45 @@
+             } else {
+                 throw new IllegalStateException("Entity has invalid position");
+             }
++
++            // CraftBukkit start
++            this.persist = !compound.contains("Bukkit.persist") || compound.getBoolean("Bukkit.persist");
++            this.visibleByDefault = !compound.contains("Bukkit.visibleByDefault") || compound.getBoolean("Bukkit.visibleByDefault");
++            // SPIGOT-6907: re-implement LivingEntity#setMaximumAir()
++            if (compound.contains("Bukkit.MaxAirSupply")) {
++                maxAirTicks = compound.getInt("Bukkit.MaxAirSupply");
++            }
++            // CraftBukkit end
++
++            // CraftBukkit start - Reset world
++            if (this instanceof ServerPlayer) {
++                Server server = Bukkit.getServer();
++                org.bukkit.World bworld = null;
++
++                // TODO: Remove World related checks, replaced with WorldUID
++                String worldName = compound.getString("world");
++
++                if (compound.contains("WorldUUIDMost") && compound.contains("WorldUUIDLeast")) {
++                    UUID uid = new UUID(compound.getLong("WorldUUIDMost"), compound.getLong("WorldUUIDLeast"));
++                    bworld = server.getWorld(uid);
++                } else {
++                    bworld = server.getWorld(worldName);
++                }
++
++                if (bworld == null) {
++                    bworld = ((org.bukkit.craftbukkit.CraftServer) server).getServer().getLevel(Level.OVERWORLD).getWorld();
++                }
++
++                ((ServerPlayer) this).setLevel(bworld == null ? null : ((CraftWorld) bworld).getHandle());
++            }
++            this.getBukkitEntity().readBukkitValues(compound);
++            if (compound.contains("Bukkit.invisible")) {
++                boolean bukkitInvisible = compound.getBoolean("Bukkit.invisible");
++                this.setInvisible(bukkitInvisible);
++                this.persistentInvisibility = bukkitInvisible;
++            }
++            // CraftBukkit end
++
+         } catch (Throwable throwable) {
+             CrashReport crashreport = CrashReport.forThrowable(throwable, "Loading entity NBT");
+             CrashReportCategory crashreportcategory = crashreport.addCategory("Entity being loaded");
+@@ -1874,6 +2164,12 @@
+         return entitytype.canSerialize() && resourcelocation != null ? resourcelocation.toString() : null;
+     }
+ 
++    // CraftBukkit start - allow excluding certain data when saving
++    protected void addAdditionalSaveData(CompoundTag nbttagcompound, boolean includeAll) {
++        addAdditionalSaveData(nbttagcompound);
++    }
++    // CraftBukkit end
++
+     protected abstract void readAdditionalSaveData(CompoundTag compound);
+ 
+     protected abstract void addAdditionalSaveData(CompoundTag compound);
+@@ -1928,11 +2224,24 @@
+         } else if (this.level().isClientSide) {
+             return null;
+         } else {
+-            ItemEntity itementity = new ItemEntity(this.level(), this.getX(), this.getY() + (double) f, this.getZ(), itemstack);
++            // CraftBukkit start - Capture drops for death event
++            if (this instanceof net.minecraft.world.entity.LivingEntity && !((net.minecraft.world.entity.LivingEntity) this).forceDrops) {
++                ((net.minecraft.world.entity.LivingEntity) this).drops.add(org.bukkit.craftbukkit.inventory.CraftItemStack.asBukkitCopy(stack));
++                return null;
++            }
++            // CraftBukkit end
++            ItemEntity entityitem = new ItemEntity(this.level(), this.getX(), this.getY() + (double) offsetY, this.getZ(), stack);
+ 
+-            itementity.setDefaultPickUpDelay();
+-            this.level().addFreshEntity(itementity);
+-            return itementity;
++            entityitem.setDefaultPickUpDelay();
++            // CraftBukkit start
++            EntityDropItemEvent event = new EntityDropItemEvent(this.getBukkitEntity(), (org.bukkit.entity.Item) entityitem.getBukkitEntity());
++            Bukkit.getPluginManager().callEvent(event);
++            if (event.isCancelled()) {
++                return null;
++            }
++            // CraftBukkit end
++            this.level().addFreshEntity(entityitem);
++            return entityitem;
+         }
+     }
+ 
+@@ -2028,6 +2337,18 @@
+             if (!flag && (!this.canRide(entity) || !entity.canAddPassenger(this))) {
+                 return false;
+             } else {
++                // CraftBukkit start
++                if (vehicle.getBukkitEntity() instanceof Vehicle && this.getBukkitEntity() instanceof LivingEntity) {
++                    VehicleEnterEvent event = new VehicleEnterEvent((Vehicle) vehicle.getBukkitEntity(), this.getBukkitEntity());
++                    // Suppress during worldgen
++                    if (this.valid) {
++                        Bukkit.getPluginManager().callEvent(event);
++                    }
++                    if (event.isCancelled()) {
++                        return false;
++                    }
++                }
++                // CraftBukkit end
+                 if (this.isPassenger()) {
+                     this.stopRiding();
+                 }
+@@ -2061,7 +2382,7 @@
+             Entity entity = this.vehicle;
+ 
+             this.vehicle = null;
+-            entity.removePassenger(this);
++            if (!entity.removePassenger(this)) this.vehicle = entity; // CraftBukkit
+         }
+ 
+     }
+@@ -2092,10 +2413,29 @@
+         }
+     }
+ 
+-    protected void removePassenger(Entity entity) {
++    protected boolean removePassenger(Entity entity) { // CraftBukkit
+         if (entity.getVehicle() == this) {
+             throw new IllegalStateException("Use x.stopRiding(y), not y.removePassenger(x)");
+         } else {
++            // CraftBukkit start
++            CraftEntity craft = (CraftEntity) entity.getBukkitEntity().getVehicle();
++            Entity orig = craft == null ? null : craft.getHandle();
++            if (getBukkitEntity() instanceof Vehicle && entity.getBukkitEntity() instanceof LivingEntity) {
++                VehicleExitEvent event = new VehicleExitEvent(
++                        (Vehicle) getBukkitEntity(),
++                        (LivingEntity) entity.getBukkitEntity()
++                );
++                // Suppress during worldgen
++                if (this.valid) {
++                    Bukkit.getPluginManager().callEvent(event);
++                }
++                CraftEntity craftn = (CraftEntity) entity.getBukkitEntity().getVehicle();
++                Entity n = craftn == null ? null : craftn.getHandle();
++                if (event.isCancelled() || n != orig) {
++                    return false;
++                }
++            }
++            // CraftBukkit end
+             if (this.passengers.size() == 1 && this.passengers.get(0) == entity) {
+                 this.passengers = ImmutableList.of();
+             } else {
+@@ -2107,6 +2447,7 @@
+             entity.boardingCooldown = 60;
+             this.gameEvent(GameEvent.ENTITY_DISMOUNT, entity);
+         }
++        return true; // CraftBukkit
+     }
+ 
+     protected boolean canAddPassenger(Entity entity) {
+@@ -2192,15 +2533,21 @@
+             ServerLevel serverlevel = (ServerLevel) this.level();
+ 
+             if (this.isInsidePortal) {
+-                MinecraftServer minecraftserver = serverlevel.getServer();
+-                ResourceKey<Level> resourcekey = this.level().dimension() == Level.NETHER ? Level.OVERWORLD : Level.NETHER;
+-                ServerLevel serverlevel1 = minecraftserver.getLevel(resourcekey);
++                MinecraftServer minecraftserver = worldserver.getServer();
++                ResourceKey<Level> resourcekey = this.level().getTypeKey() == LevelStem.NETHER ? Level.OVERWORLD : Level.NETHER; // CraftBukkit
++                ServerLevel worldserver1 = minecraftserver.getLevel(resourcekey);
+ 
+-                if (serverlevel1 != null && minecraftserver.isNetherEnabled() && !this.isPassenger() && this.portalTime++ >= i) {
++                if (true && !this.isPassenger() && this.portalTime++ >= i) { // CraftBukkit
+                     this.level().getProfiler().push("portal");
+                     this.portalTime = i;
+                     this.setPortalCooldown();
+-                    this.changeDimension(serverlevel1);
++                    // CraftBukkit start
++                    if (this instanceof ServerPlayer) {
++                        ((ServerPlayer) this).changeDimension(worldserver1, PlayerTeleportEvent.TeleportCause.NETHER_PORTAL);
++                    } else {
++                        this.changeDimension(worldserver1);
++                    }
++                    // CraftBukkit end
+                     this.level().getProfiler().pop();
+                 }
+ 
+@@ -2323,8 +2670,15 @@
+         return this.isVisuallySwimming() && !this.isInWater();
+     }
+ 
+-    public void setSwimming(boolean flag) {
+-        this.setSharedFlag(4, flag);
++    public void setSwimming(boolean swimming) {
++        // CraftBukkit start
++        if (valid && this.isSwimming() != swimming && this instanceof net.minecraft.world.entity.LivingEntity) {
++            if (CraftEventFactory.callToggleSwimEvent((net.minecraft.world.entity.LivingEntity) this, swimming).isCancelled()) {
++                return;
++            }
++        }
++        // CraftBukkit end
++        this.setSharedFlag(4, swimming);
+     }
+ 
+     public final boolean hasGlowingTag() {
+@@ -2373,8 +2727,12 @@
+         return this.getTeam() != null ? this.getTeam().isAlliedTo(team) : false;
+     }
+ 
+-    public void setInvisible(boolean flag) {
+-        this.setSharedFlag(5, flag);
++    // CraftBukkit - start
++    public void setInvisible(boolean invisible) {
++        if (!this.persistentInvisibility) { // Prevent Minecraft from removing our invisibility flag
++            this.setSharedFlag(5, invisible);
++        }
++        // CraftBukkit - end
+     }
+ 
+     protected boolean getSharedFlag(int i) {
+@@ -2393,15 +2751,26 @@
+     }
+ 
+     public int getMaxAirSupply() {
+-        return 300;
++        return maxAirTicks; // CraftBukkit - SPIGOT-6907: re-implement LivingEntity#setMaximumAir()
+     }
+ 
+     public int getAirSupply() {
+         return (Integer) this.entityData.get(Entity.DATA_AIR_SUPPLY_ID);
+     }
+ 
+-    public void setAirSupply(int i) {
+-        this.entityData.set(Entity.DATA_AIR_SUPPLY_ID, i);
++    public void setAirSupply(int air) {
++        // CraftBukkit start
++        EntityAirChangeEvent event = new EntityAirChangeEvent(this.getBukkitEntity(), air);
++        // Suppress during worldgen
++        if (this.valid) {
++            event.getEntity().getServer().getPluginManager().callEvent(event);
++        }
++        if (event.isCancelled() && this.getAirSupply() != air) {
++            this.entityData.markDirty(Entity.DATA_AIR_SUPPLY_ID);
++            return;
++        }
++        this.entityData.set(Entity.DATA_AIR_SUPPLY_ID, event.getAmount());
++        // CraftBukkit end
+     }
+ 
+     public int getTicksFrozen() {
+@@ -2428,11 +2797,41 @@
+ 
+     public void thunderHit(ServerLevel serverlevel, LightningBolt lightningbolt) {
+         this.setRemainingFireTicks(this.remainingFireTicks + 1);
++        // CraftBukkit start
++        final org.bukkit.entity.Entity thisBukkitEntity = this.getBukkitEntity();
++        final org.bukkit.entity.Entity stormBukkitEntity = lightning.getBukkitEntity();
++        final PluginManager pluginManager = Bukkit.getPluginManager();
++        // CraftBukkit end
++
+         if (this.remainingFireTicks == 0) {
+-            this.setSecondsOnFire(8);
++            // CraftBukkit start - Call a combust event when lightning strikes
++            EntityCombustByEntityEvent entityCombustEvent = new EntityCombustByEntityEvent(stormBukkitEntity, thisBukkitEntity, 8);
++            pluginManager.callEvent(entityCombustEvent);
++            if (!entityCombustEvent.isCancelled()) {
++                this.setSecondsOnFire(entityCombustEvent.getDuration(), false);
++            }
++            // CraftBukkit end
+         }
+ 
+-        this.hurt(this.damageSources().lightningBolt(), 5.0F);
++        // CraftBukkit start
++        if (thisBukkitEntity instanceof Hanging) {
++            HangingBreakByEntityEvent hangingEvent = new HangingBreakByEntityEvent((Hanging) thisBukkitEntity, stormBukkitEntity);
++            pluginManager.callEvent(hangingEvent);
++
++            if (hangingEvent.isCancelled()) {
++                return;
++            }
++        }
++
++        if (this.fireImmune()) {
++            return;
++        }
++        CraftEventFactory.entityDamage = lightning;
++        if (!this.hurt(this.damageSources().lightningBolt(), 5.0F)) {
++            CraftEventFactory.entityDamage = null;
++            return;
++        }
++        // CraftBukkit end
+     }
+ 
+     public void onAboveBubbleCol(boolean flag) {
+@@ -2598,27 +2995,62 @@
+     }
+ 
+     @Nullable
+-    public Entity changeDimension(ServerLevel serverlevel) {
++    public Entity changeDimension(ServerLevel destination) {
++        // CraftBukkit start
++        return teleportTo(destination, null);
++    }
++
++    @Nullable
++    public Entity teleportTo(ServerLevel worldserver, Vec3 location) {
++        // CraftBukkit end
+         if (this.level() instanceof ServerLevel && !this.isRemoved()) {
+             this.level().getProfiler().push("changeDimension");
+-            this.unRide();
++            // CraftBukkit start
++            // this.unRide();
++            if (worldserver == null) {
++                return null;
++            }
++            // CraftBukkit end
+             this.level().getProfiler().push("reposition");
+-            PortalInfo portalinfo = this.findDimensionEntryPoint(serverlevel);
++            PortalInfo shapedetectorshape = (location == null) ? this.findDimensionEntryPoint(worldserver) : new PortalInfo(new Vec3(location.x(), location.y(), location.z()), Vec3.ZERO, this.yRot, this.xRot, worldserver, null); // CraftBukkit
+ 
+             if (portalinfo == null) {
+                 return null;
+             } else {
++                // CraftBukkit start
++                worldserver = shapedetectorshape.world;
++                if (worldserver == level) {
++                    // SPIGOT-6782: Just move the entity if a plugin changed the world to the one the entity is already in
++                    moveTo(shapedetectorshape.pos.x, shapedetectorshape.pos.y, shapedetectorshape.pos.z, shapedetectorshape.yRot, shapedetectorshape.xRot);
++                    setDeltaMovement(shapedetectorshape.speed);
++                    return this;
++                }
++                this.unRide();
++                // CraftBukkit end
++
+                 this.level().getProfiler().popPush("reloading");
+                 Entity entity = this.getType().create(serverlevel);
+ 
+                 if (entity != null) {
+                     entity.restoreFrom(this);
+-                    entity.moveTo(portalinfo.pos.x, portalinfo.pos.y, portalinfo.pos.z, portalinfo.yRot, entity.getXRot());
+-                    entity.setDeltaMovement(portalinfo.speed);
+-                    serverlevel.addDuringTeleport(entity);
+-                    if (serverlevel.dimension() == Level.END) {
+-                        ServerLevel.makeObsidianPlatform(serverlevel);
++                    entity.moveTo(shapedetectorshape.pos.x, shapedetectorshape.pos.y, shapedetectorshape.pos.z, shapedetectorshape.yRot, entity.getXRot());
++                    entity.setDeltaMovement(shapedetectorshape.speed);
++                    // CraftBukkit start - Don't spawn the new entity if the current entity isn't spawned
++                    if (this.inWorld) {
++                        worldserver.addDuringTeleport(entity);
++                        if (worldserver.getTypeKey() == LevelStem.END) { // CraftBukkit
++                            ServerLevel.makeObsidianPlatform(worldserver, this); // CraftBukkit
++                        }
+                     }
++                    // CraftBukkit end
++                    // CraftBukkit start - Forward the CraftEntity to the new entity
++                    this.getBukkitEntity().setHandle(entity);
++                    entity.bukkitEntity = this.getBukkitEntity();
++
++                    if (this instanceof Mob) {
++                        ((Mob) this).dropLeash(true, false); // Unleash to prevent duping of leads.
++                    }
++                    // CraftBukkit end
+                 }
+ 
+                 this.removeAfterChangingDimensions();
+@@ -2638,24 +3070,38 @@
+     }
+ 
+     @Nullable
+-    protected PortalInfo findDimensionEntryPoint(ServerLevel serverlevel) {
+-        boolean flag = this.level().dimension() == Level.END && serverlevel.dimension() == Level.OVERWORLD;
+-        boolean flag1 = serverlevel.dimension() == Level.END;
++    protected PortalInfo findDimensionEntryPoint(ServerLevel destination) {
++        // CraftBukkit start
++        if (destination == null) {
++            return null;
++        }
++        boolean flag = this.level().getTypeKey() == LevelStem.END && destination.getTypeKey() == LevelStem.OVERWORLD; // fromEndToOverworld
++        boolean flag1 = destination.getTypeKey() == LevelStem.END; // targetIsEnd
++        // CraftBukkit end
+ 
+         if (!flag && !flag1) {
+-            boolean flag2 = serverlevel.dimension() == Level.NETHER;
++            boolean flag2 = destination.getTypeKey() == LevelStem.NETHER; // CraftBukkit
+ 
+-            if (this.level().dimension() != Level.NETHER && !flag2) {
++            if (this.level().getTypeKey() != LevelStem.NETHER && !flag2) { // CraftBukkit
+                 return null;
+             } else {
+-                WorldBorder worldborder = serverlevel.getWorldBorder();
+-                double d0 = DimensionType.getTeleportationScale(this.level().dimensionType(), serverlevel.dimensionType());
+-                BlockPos blockpos = worldborder.clampToBounds(this.getX() * d0, this.getY(), this.getZ() * d0);
++                WorldBorder worldborder = destination.getWorldBorder();
++                double d0 = DimensionType.getTeleportationScale(this.level().dimensionType(), destination.dimensionType());
++                BlockPos blockposition = worldborder.clampToBounds(this.getX() * d0, this.getY(), this.getZ() * d0);
++                // CraftBukkit start
++                CraftPortalEvent event = callPortalEvent(this, destination, new Vec3(blockposition.getX(), blockposition.getY(), blockposition.getZ()), PlayerTeleportEvent.TeleportCause.NETHER_PORTAL, flag2 ? 16 : 128, 16);
++                if (event == null) {
++                    return null;
++                }
++                final ServerLevel worldserverFinal = destination = ((CraftWorld) event.getTo().getWorld()).getHandle();
++                worldborder = worldserverFinal.getWorldBorder();
++                blockposition = worldborder.clampToBounds(event.getTo().getX(), event.getTo().getY(), event.getTo().getZ());
+ 
+-                return (PortalInfo) this.getExitPortal(serverlevel, blockpos, flag2, worldborder).map((blockutil_foundrectangle) -> {
+-                    BlockState blockstate = this.level().getBlockState(this.portalEntrancePos);
+-                    Direction.Axis direction_axis;
+-                    Vec3 vec3;
++                return (PortalInfo) this.getExitPortal(destination, blockposition, flag2, worldborder, event.getSearchRadius(), event.getCanCreatePortal(), event.getCreationRadius()).map((blockutil_rectangle) -> {
++                    // CraftBukkit end
++                    IBlockData iblockdata = this.level().getBlockState(this.portalEntrancePos);
++                    Direction.Axis enumdirection_enumaxis;
++                    Vec3 vec3d;
+ 
+                     if (blockstate.hasProperty(BlockStateProperties.HORIZONTAL_AXIS)) {
+                         direction_axis = (Direction.Axis) blockstate.getValue(BlockStateProperties.HORIZONTAL_AXIS);
+@@ -2669,8 +3115,8 @@
+                         vec3 = new Vec3(0.5D, 0.0D, 0.0D);
+                     }
+ 
+-                    return PortalShape.createPortalInfo(serverlevel, blockutil_foundrectangle, direction_axis, vec3, this, this.getDeltaMovement(), this.getYRot(), this.getXRot());
+-                }).orElse((Object) null);
++                    return PortalShape.createPortalInfo(worldserverFinal, blockutil_rectangle, enumdirection_enumaxis, vec3d, this, this.getDeltaMovement(), this.getYRot(), this.getXRot(), event); // CraftBukkit
++                }).orElse(null); // CraftBukkit - decompile error
+             }
+         } else {
+             BlockPos blockpos1;
+@@ -2680,8 +3126,14 @@
+             } else {
+                 blockpos1 = serverlevel.getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, serverlevel.getSharedSpawnPos());
+             }
++            // CraftBukkit start
++            CraftPortalEvent event = callPortalEvent(this, destination, new Vec3(blockposition1.getX() + 0.5D, blockposition1.getY(), blockposition1.getZ() + 0.5D), PlayerTeleportEvent.TeleportCause.END_PORTAL, 0, 0);
++            if (event == null) {
++                return null;
++            }
+ 
+-            return new PortalInfo(new Vec3((double) blockpos1.getX() + 0.5D, (double) blockpos1.getY(), (double) blockpos1.getZ() + 0.5D), this.getDeltaMovement(), this.getYRot(), this.getXRot());
++            return new PortalInfo(new Vec3(event.getTo().getX(), event.getTo().getY(), event.getTo().getZ()), this.getDeltaMovement(), this.getYRot(), this.getXRot(), ((CraftWorld) event.getTo().getWorld()).getHandle(), event);
++            // CraftBukkit end
+         }
+     }
+ 
+@@ -2689,10 +3141,25 @@
+         return PortalShape.getRelativePosition(blockutil_foundrectangle, direction_axis, this.position(), this.getDimensions(this.getPose()));
+     }
+ 
+-    protected Optional<BlockUtil.FoundRectangle> getExitPortal(ServerLevel serverlevel, BlockPos blockpos, boolean flag, WorldBorder worldborder) {
+-        return serverlevel.getPortalForcer().findPortalAround(blockpos, flag, worldborder);
++    // CraftBukkit start
++    protected CraftPortalEvent callPortalEvent(Entity entity, ServerLevel exitWorldServer, Vec3 exitPosition, PlayerTeleportEvent.TeleportCause cause, int searchRadius, int creationRadius) {
++        org.bukkit.entity.Entity bukkitEntity = entity.getBukkitEntity();
++        Location enter = bukkitEntity.getLocation();
++        Location exit = CraftLocation.toBukkit(exitPosition, exitWorldServer.getWorld());
++
++        EntityPortalEvent event = new EntityPortalEvent(bukkitEntity, enter, exit, searchRadius);
++        event.getEntity().getServer().getPluginManager().callEvent(event);
++        if (event.isCancelled() || event.getTo() == null || event.getTo().getWorld() == null || !entity.isAlive()) {
++            return null;
++        }
++        return new CraftPortalEvent(event);
+     }
+ 
++    protected Optional<BlockUtil.FoundRectangle> getExitPortal(ServerLevel worldserver, BlockPos blockposition, boolean flag, WorldBorder worldborder, int searchRadius, boolean canCreatePortal, int createRadius) {
++        return worldserver.getPortalForcer().findPortalAround(blockposition, worldborder, searchRadius);
++        // CraftBukkit end
++    }
++
+     public boolean canChangeDimensions() {
+         return !this.isPassenger() && !this.isVehicle();
+     }
+@@ -2816,7 +3278,13 @@
+         }
+     }
+ 
+-    public boolean teleportTo(ServerLevel serverlevel, double d0, double d1, double d2, Set<RelativeMovement> set, float f, float f1) {
++    // CraftBukkit start
++    public boolean teleportTo(ServerLevel worldserver, double d0, double d1, double d2, Set<RelativeMovement> set, float f, float f1, org.bukkit.event.player.PlayerTeleportEvent.TeleportCause cause) {
++        return this.teleportTo(worldserver, d0, d1, d2, set, f, f1);
++    }
++    // CraftBukkit end
++
++    public boolean teleportTo(ServerLevel level, double x, double d1, double y, Set<RelativeMovement> set, float z, float f1) {
+         float f2 = Mth.clamp(f1, -90.0F, 90.0F);
+ 
+         if (serverlevel == this.level()) {
+@@ -2835,7 +3303,11 @@
+             entity.moveTo(d0, d1, d2, f, f2);
+             entity.setYHeadRot(f);
+             this.setRemoved(Entity.RemovalReason.CHANGED_DIMENSION);
+-            serverlevel.addDuringTeleport(entity);
++            // CraftBukkit start - Don't spawn the new entity if the current entity isn't spawned
++            if (inWorld) {
++                level.addDuringTeleport(entity);
++            }
++            // CraftBukkit end
+         }
+ 
+         return true;
+@@ -2941,8 +3412,27 @@
+         return this.getBoundingBox();
+     }
+ 
+-    public final void setBoundingBox(AABB aabb) {
+-        this.bb = aabb;
++    public final void setBoundingBox(AABB bb) {
++        // CraftBukkit start - block invalid bounding boxes
++        double minX = bb.minX,
++                minY = bb.minY,
++                minZ = bb.minZ,
++                maxX = bb.maxX,
++                maxY = bb.maxY,
++                maxZ = bb.maxZ;
++        double len = bb.maxX - bb.minX;
++        if (len < 0) maxX = minX;
++        if (len > 64) maxX = minX + 64.0;
++
++        len = bb.maxY - bb.minY;
++        if (len < 0) maxY = minY;
++        if (len > 64) maxY = minY + 64.0;
++
++        len = bb.maxZ - bb.minZ;
++        if (len < 0) maxZ = minZ;
++        if (len > 64) maxZ = minZ + 64.0;
++        this.bb = new AABB(minX, minY, minZ, maxX, maxY, maxZ);
++        // CraftBukkit end
+     }
+ 
+     protected float getEyeHeight(Pose pose, EntityDimensions entitydimensions) {
+@@ -3263,6 +3747,11 @@
+                                     vec3 = vec3.add(vec31);
+                                     ++k1;
+                                 }
++                                // CraftBukkit start - store last lava contact location
++                                if (fluidTag == FluidTags.LAVA) {
++                                    this.lastLavaContact = blockposition_mutableblockposition.immutable();
++                                }
++                                // CraftBukkit end
+                             }
+                         }
+                     }