Repackage patches

By: md_5 <git@md-5.net>

paper-server/nms-patches/net/minecraft/world/level/CommandBlockListenerAbstract.patch

@@ -0,0 +1,22 @@
+--- a/net/minecraft/server/CommandBlockListenerAbstract.java
++++ b/net/minecraft/server/CommandBlockListenerAbstract.java
+@@ -17,6 +17,10 @@
+     private IChatBaseComponent lastOutput;
+     private String command = "";
+     private IChatBaseComponent customName;
++    // CraftBukkit start
++    @Override
++    public abstract org.bukkit.command.CommandSender getBukkitSender(CommandListenerWrapper wrapper);
++    // CraftBukkit end
+ 
+     public CommandBlockListenerAbstract() {
+         this.customName = CommandBlockListenerAbstract.c;
+@@ -113,7 +117,7 @@
+ 
+                         });
+ 
+-                        minecraftserver.getCommandDispatcher().a(commandlistenerwrapper, this.command);
++                        minecraftserver.getCommandDispatcher().dispatchServerCommand(commandlistenerwrapper, this.command); // CraftBukkit
+                     } catch (Throwable throwable) {
+                         CrashReport crashreport = CrashReport.a(throwable, "Executing command block");
+                         CrashReportSystemDetails crashreportsystemdetails = crashreport.a("Command to be executed");

paper-server/nms-patches/net/minecraft/world/level/Explosion.patch

@@ -0,0 +1,153 @@
+--- a/net/minecraft/server/Explosion.java
++++ b/net/minecraft/server/Explosion.java
+@@ -15,6 +15,13 @@
+ import java.util.Set;
+ import javax.annotation.Nullable;
+ 
++// CraftBukkit start
++import org.bukkit.craftbukkit.event.CraftEventFactory;
++import org.bukkit.event.entity.EntityExplodeEvent;
++import org.bukkit.Location;
++import org.bukkit.event.block.BlockExplodeEvent;
++// CraftBukkit end
++
+ public class Explosion {
+ 
+     private static final ExplosionDamageCalculator a = new ExplosionDamageCalculator();
+@@ -32,11 +39,12 @@
+     private final ExplosionDamageCalculator l;
+     private final List<BlockPosition> blocks = Lists.newArrayList();
+     private final Map<EntityHuman, Vec3D> n = Maps.newHashMap();
++    public boolean wasCanceled = false; // CraftBukkit - add field
+ 
+     public Explosion(World world, @Nullable Entity entity, @Nullable DamageSource damagesource, @Nullable ExplosionDamageCalculator explosiondamagecalculator, double d0, double d1, double d2, float f, boolean flag, Explosion.Effect explosion_effect) {
+         this.world = world;
+         this.source = entity;
+-        this.size = f;
++        this.size = (float) Math.max(f, 0.0); // CraftBukkit - clamp bad values
+         this.posX = d0;
+         this.posY = d1;
+         this.posZ = d2;
+@@ -86,6 +94,11 @@
+     }
+ 
+     public void a() {
++        // CraftBukkit start
++        if (this.size < 0.1F) {
++            return;
++        }
++        // CraftBukkit end
+         Set<BlockPosition> set = Sets.newHashSet();
+         boolean flag = true;
+ 
+@@ -119,7 +132,7 @@
+                                 f -= ((Float) optional.get() + 0.3F) * 0.3F;
+                             }
+ 
+-                            if (f > 0.0F && this.l.a(this, this.world, blockposition, iblockdata, f)) {
++                            if (f > 0.0F && this.l.a(this, this.world, blockposition, iblockdata, f) && blockposition.getY() < 256 && blockposition.getY() >= 0) { // CraftBukkit - don't wrap explosions
+                                 set.add(blockposition);
+                             }
+ 
+@@ -163,7 +176,16 @@
+                         double d12 = (double) a(vec3d, entity);
+                         double d13 = (1.0D - d7) * d12;
+ 
+-                        entity.damageEntity(this.b(), (float) ((int) ((d13 * d13 + d13) / 2.0D * 7.0D * (double) f2 + 1.0D)));
++                        // CraftBukkit start
++                        // entity.damageEntity(this.b(), (float) ((int) ((d13 * d13 + d13) / 2.0D * 7.0D * (double) f2 + 1.0D)));
++                        CraftEventFactory.entityDamage = source;
++                        entity.forceExplosionKnockback = false;
++                        boolean wasDamaged = entity.damageEntity(this.b(), (float) ((int) ((d13 * d13 + d13) / 2.0D * 7.0D * (double) f2 + 1.0D)));
++                        CraftEventFactory.entityDamage = null;
++                        if (!wasDamaged && !(entity instanceof EntityTNTPrimed || entity instanceof EntityFallingBlock) && !entity.forceExplosionKnockback) {
++                            continue;
++                        }
++                        // CraftBukkit end
+                         double d14 = d13;
+ 
+                         if (entity instanceof EntityLiving) {
+@@ -205,6 +227,51 @@
+ 
+             Collections.shuffle(this.blocks, this.world.random);
+             Iterator iterator = this.blocks.iterator();
++            // CraftBukkit start
++            org.bukkit.World bworld = this.world.getWorld();
++            org.bukkit.entity.Entity explode = this.source == null ? null : this.source.getBukkitEntity();
++            Location location = new Location(bworld, this.posX, this.posY, this.posZ);
++
++            List<org.bukkit.block.Block> blockList = Lists.newArrayList();
++            for (int i1 = this.blocks.size() - 1; i1 >= 0; i1--) {
++                BlockPosition cpos = (BlockPosition) this.blocks.get(i1);
++                org.bukkit.block.Block bblock = bworld.getBlockAt(cpos.getX(), cpos.getY(), cpos.getZ());
++                if (!bblock.getType().isAir()) {
++                    blockList.add(bblock);
++                }
++            }
++
++            boolean cancelled;
++            List<org.bukkit.block.Block> bukkitBlocks;
++            float yield;
++
++            if (explode != null) {
++                EntityExplodeEvent event = new EntityExplodeEvent(explode, location, blockList, this.c == Explosion.Effect.DESTROY ? 1.0F / this.size : 1.0F);
++                this.world.getServer().getPluginManager().callEvent(event);
++                cancelled = event.isCancelled();
++                bukkitBlocks = event.blockList();
++                yield = event.getYield();
++            } else {
++                BlockExplodeEvent event = new BlockExplodeEvent(location.getBlock(), blockList, this.c == Explosion.Effect.DESTROY ? 1.0F / this.size : 1.0F);
++                this.world.getServer().getPluginManager().callEvent(event);
++                cancelled = event.isCancelled();
++                bukkitBlocks = event.blockList();
++                yield = event.getYield();
++            }
++
++            this.blocks.clear();
++
++            for (org.bukkit.block.Block bblock : bukkitBlocks) {
++                BlockPosition coords = new BlockPosition(bblock.getX(), bblock.getY(), bblock.getZ());
++                blocks.add(coords);
++            }
++
++            if (cancelled) {
++                this.wasCanceled = true;
++                return;
++            }
++            // CraftBukkit end
++            iterator = this.blocks.iterator();
+ 
+             while (iterator.hasNext()) {
+                 BlockPosition blockposition = (BlockPosition) iterator.next();
+@@ -219,8 +286,8 @@
+                         TileEntity tileentity = block.isTileEntity() ? this.world.getTileEntity(blockposition) : null;
+                         LootTableInfo.Builder loottableinfo_builder = (new LootTableInfo.Builder((WorldServer) this.world)).a(this.world.random).set(LootContextParameters.ORIGIN, Vec3D.a((BaseBlockPosition) blockposition)).set(LootContextParameters.TOOL, ItemStack.b).setOptional(LootContextParameters.BLOCK_ENTITY, tileentity).setOptional(LootContextParameters.THIS_ENTITY, this.source);
+ 
+-                        if (this.c == Explosion.Effect.DESTROY) {
+-                            loottableinfo_builder.set(LootContextParameters.EXPLOSION_RADIUS, this.size);
++                        if (this.c == Explosion.Effect.DESTROY || yield < 1.0F) { // CraftBukkit - add yield
++                            loottableinfo_builder.set(LootContextParameters.EXPLOSION_RADIUS, 1.0F / yield); // CraftBukkit - add yield
+                         }
+ 
+                         iblockdata.a(loottableinfo_builder).forEach((itemstack) -> {
+@@ -250,7 +317,11 @@
+                 BlockPosition blockposition2 = (BlockPosition) iterator1.next();
+ 
+                 if (this.d.nextInt(3) == 0 && this.world.getType(blockposition2).isAir() && this.world.getType(blockposition2.down()).i(this.world, blockposition2.down())) {
+-                    this.world.setTypeUpdate(blockposition2, BlockFireAbstract.a((IBlockAccess) this.world, blockposition2));
++                    // CraftBukkit start - Ignition by explosion
++                    if (!org.bukkit.craftbukkit.event.CraftEventFactory.callBlockIgniteEvent(this.world, blockposition2.getX(), blockposition2.getY(), blockposition2.getZ(), this).isCancelled()) {
++                        this.world.setTypeUpdate(blockposition2, BlockFireAbstract.a((IBlockAccess) this.world, blockposition2));
++                    }
++                    // CraftBukkit end
+                 }
+             }
+         }
+@@ -258,6 +329,7 @@
+     }
+ 
+     private static void a(ObjectArrayList<Pair<ItemStack, BlockPosition>> objectarraylist, ItemStack itemstack, BlockPosition blockposition) {
++        if (itemstack.isEmpty()) return; // CraftBukkit - SPIGOT-5425
+         int i = objectarraylist.size();
+ 
+         for (int j = 0; j < i; ++j) {

paper-server/nms-patches/net/minecraft/world/level/GameRules.patch

@@ -0,0 +1,58 @@
+--- a/net/minecraft/server/GameRules.java
++++ b/net/minecraft/server/GameRules.java
+@@ -106,7 +106,7 @@
+     }
+ 
+     public <T extends GameRules.GameRuleValue<T>> T get(GameRules.GameRuleKey<T> gamerules_gamerulekey) {
+-        return (GameRules.GameRuleValue) this.J.get(gamerules_gamerulekey);
++        return (T) this.J.get(gamerules_gamerulekey); // CraftBukkit - decompile error
+     }
+ 
+     public NBTTagCompound a() {
+@@ -137,8 +137,8 @@
+     }
+ 
+     private static <T extends GameRules.GameRuleValue<T>> void a(GameRules.GameRuleVisitor gamerules_gamerulevisitor, GameRules.GameRuleKey<?> gamerules_gamerulekey, GameRules.GameRuleDefinition<?> gamerules_gameruledefinition) {
+-        gamerules_gamerulevisitor.a(gamerules_gamerulekey, gamerules_gameruledefinition);
+-        gamerules_gameruledefinition.a(gamerules_gamerulevisitor, gamerules_gamerulekey);
++        gamerules_gamerulevisitor.a((GameRules.GameRuleKey<T>) gamerules_gamerulekey, (GameRules.GameRuleDefinition<T>) gamerules_gameruledefinition); // CraftBukkit - decompile error
++        ((GameRules.GameRuleDefinition<T>) gamerules_gameruledefinition).a(gamerules_gamerulevisitor, (GameRules.GameRuleKey<T>) gamerules_gamerulekey); // CraftBukkit - decompile error
+     }
+ 
+     public boolean getBoolean(GameRules.GameRuleKey<GameRules.GameRuleBoolean> gamerules_gamerulekey) {
+@@ -189,7 +189,7 @@
+         }
+ 
+         @Override
+-        protected void setValue(String s) {
++        public void setValue(String s) { // PAIL - protected->public
+             this.b = Boolean.parseBoolean(s);
+         }
+ 
+@@ -244,7 +244,7 @@
+         }
+ 
+         @Override
+-        protected void setValue(String s) {
++        public void setValue(String s) { // PAIL - protected->public
+             this.b = c(s);
+         }
+ 
+@@ -298,7 +298,7 @@
+ 
+         }
+ 
+-        protected abstract void setValue(String s);
++        public abstract void setValue(String s); // PAIL - private->public
+ 
+         public abstract String getValue();
+ 
+@@ -332,7 +332,7 @@
+         }
+ 
+         public T getValue() {
+-            return (GameRules.GameRuleValue) this.b.apply(this);
++            return this.b.apply(this); // CraftBukkit - decompile error
+         }
+ 
+         public void a(GameRules.GameRuleVisitor gamerules_gamerulevisitor, GameRules.GameRuleKey<T> gamerules_gamerulekey) {

paper-server/nms-patches/net/minecraft/world/level/GeneratorAccess.patch

@@ -0,0 +1,9 @@
+--- a/net/minecraft/server/GeneratorAccess.java
++++ b/net/minecraft/server/GeneratorAccess.java
+@@ -46,4 +46,6 @@
+     default void triggerEffect(int i, BlockPosition blockposition, int j) {
+         this.a((EntityHuman) null, i, blockposition, j);
+     }
++
++    WorldServer getMinecraftWorld(); // CraftBukkit
+ }

paper-server/nms-patches/net/minecraft/world/level/IBlockAccess.patch

@@ -0,0 +1,35 @@
+--- a/net/minecraft/server/IBlockAccess.java
++++ b/net/minecraft/server/IBlockAccess.java
+@@ -31,8 +31,8 @@
+         return BlockPosition.a(axisalignedbb).map(this::getType);
+     }
+ 
+-    default MovingObjectPositionBlock rayTrace(RayTrace raytrace) {
+-        return (MovingObjectPositionBlock) a(raytrace, (raytrace1, blockposition) -> {
++    // CraftBukkit start - moved block handling into separate method for use by Block#rayTrace
++    default MovingObjectPositionBlock rayTraceBlock(RayTrace raytrace1, BlockPosition blockposition) {
+             IBlockData iblockdata = this.getType(blockposition);
+             Fluid fluid = this.getFluid(blockposition);
+             Vec3D vec3d = raytrace1.b();
+@@ -45,6 +45,12 @@
+             double d1 = movingobjectpositionblock1 == null ? Double.MAX_VALUE : raytrace1.b().distanceSquared(movingobjectpositionblock1.getPos());
+ 
+             return d0 <= d1 ? movingobjectpositionblock : movingobjectpositionblock1;
++    }
++    // CraftBukkit end
++
++    default MovingObjectPositionBlock rayTrace(RayTrace raytrace) {
++        return (MovingObjectPositionBlock) a(raytrace, (raytrace1, blockposition) -> {
++            return this.rayTraceBlock(raytrace1, blockposition); // CraftBukkit - moved into separate method
+         }, (raytrace1) -> {
+             Vec3D vec3d = raytrace1.b().d(raytrace1.a());
+ 
+@@ -120,7 +126,7 @@
+                 double d13 = d10 * (i1 > 0 ? 1.0D - MathHelper.h(d4) : MathHelper.h(d4));
+                 double d14 = d11 * (j1 > 0 ? 1.0D - MathHelper.h(d5) : MathHelper.h(d5));
+ 
+-                Object object;
++                T object; // CraftBukkit - decompile error
+ 
+                 do {
+                     if (d12 > 1.0D && d13 > 1.0D && d14 > 1.0D) {

paper-server/nms-patches/net/minecraft/world/level/IWorldWriter.patch

@@ -0,0 +1,13 @@
+--- a/net/minecraft/server/IWorldWriter.java
++++ b/net/minecraft/server/IWorldWriter.java
+@@ -25,4 +25,10 @@
+     default boolean addEntity(Entity entity) {
+         return false;
+     }
++
++    // CraftBukkit start
++    default boolean addEntity(Entity entity, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason reason) {
++        return false;
++    }
++    // CraftBukkit end
+ }

paper-server/nms-patches/net/minecraft/world/level/MobSpawnerAbstract.patch

@@ -0,0 +1,19 @@
+--- a/net/minecraft/server/MobSpawnerAbstract.java
++++ b/net/minecraft/server/MobSpawnerAbstract.java
+@@ -43,6 +43,7 @@
+ 
+     public void setMobName(EntityTypes<?> entitytypes) {
+         this.spawnData.getEntity().setString("id", IRegistry.ENTITY_TYPE.getKey(entitytypes).toString());
++        this.mobs.clear(); // CraftBukkit - SPIGOT-3496, MC-92282
+     }
+ 
+     private boolean h() {
+@@ -132,7 +133,7 @@
+                                 }
+                             }
+ 
+-                            if (!worldserver.addAllEntitiesSafely(entity)) {
++                            if (!worldserver.addAllEntitiesSafely(entity, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.SPAWNER)) { // CraftBukkit
+                                 this.i();
+                                 return;
+                             }

paper-server/nms-patches/net/minecraft/world/level/RayTrace.patch

@@ -0,0 +1,20 @@
+--- a/net/minecraft/server/RayTrace.java
++++ b/net/minecraft/server/RayTrace.java
+@@ -15,7 +15,7 @@
+         this.b = vec3d1;
+         this.c = raytrace_blockcollisionoption;
+         this.d = raytrace_fluidcollisionoption;
+-        this.e = VoxelShapeCollision.a(entity);
++        this.e = (entity == null) ? VoxelShapeCollision.a() : VoxelShapeCollision.a(entity); // CraftBukkit
+     }
+ 
+     public Vec3D a() {
+@@ -44,7 +44,7 @@
+ 
+         private final Predicate<Fluid> predicate;
+ 
+-        private FluidCollisionOption(Predicate predicate) {
++        private FluidCollisionOption(Predicate<Fluid> predicate) { // CraftBukkit - decompile error
+             this.predicate = predicate;
+         }
+ 

paper-server/nms-patches/net/minecraft/world/level/SpawnerCreature.patch

@@ -0,0 +1,115 @@
+--- a/net/minecraft/server/SpawnerCreature.java
++++ b/net/minecraft/server/SpawnerCreature.java
+@@ -13,6 +13,10 @@
+ import org.apache.logging.log4j.LogManager;
+ import org.apache.logging.log4j.Logger;
+ 
++// CraftBukkit start
++import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason;
++// CraftBukkit end
++
+ public final class SpawnerCreature {
+ 
+     private static final Logger LOGGER = LogManager.getLogger();
+@@ -34,7 +38,8 @@
+             if (entity instanceof EntityInsentient) {
+                 EntityInsentient entityinsentient = (EntityInsentient) entity;
+ 
+-                if (entityinsentient.isPersistent() || entityinsentient.isSpecialPersistence()) {
++                // CraftBukkit - Split out persistent check, don't apply it to special persistent mobs
++                if (entityinsentient.isTypeNotPersistent(0) && entityinsentient.isPersistent()) {
+                     continue;
+                 }
+             }
+@@ -69,10 +74,49 @@
+         EnumCreatureType[] aenumcreaturetype = SpawnerCreature.c;
+         int i = aenumcreaturetype.length;
+ 
++        // CraftBukkit start - Other mob type spawn tick rate
++        WorldData worlddata = worldserver.getWorldData();
++        boolean spawnAnimalThisTick = worldserver.ticksPerAnimalSpawns != 0L && worlddata.getTime() % worldserver.ticksPerAnimalSpawns == 0L;
++        boolean spawnMonsterThisTick = worldserver.ticksPerMonsterSpawns != 0L && worlddata.getTime() % worldserver.ticksPerMonsterSpawns == 0L;
++        boolean spawnWaterThisTick = worldserver.ticksPerWaterSpawns != 0L && worlddata.getTime() % worldserver.ticksPerWaterSpawns == 0L;
++        boolean spawnAmbientThisTick = worldserver.ticksPerAmbientSpawns != 0L && worlddata.getTime() % worldserver.ticksPerAmbientSpawns == 0L;
++        boolean spawnWaterAmbientThisTick = worldserver.ticksPerWaterAmbientSpawns != 0L && worlddata.getTime() % worldserver.ticksPerWaterAmbientSpawns == 0L;
++        // CraftBukkit end
++
+         for (int j = 0; j < i; ++j) {
+             EnumCreatureType enumcreaturetype = aenumcreaturetype[j];
++            // CraftBukkit start - Use per-world spawn limits
++            boolean spawnThisTick = true;
++            int limit = enumcreaturetype.c();
++            switch (enumcreaturetype) {
++                case MONSTER:
++                    spawnThisTick = spawnMonsterThisTick;
++                    limit = worldserver.getWorld().getMonsterSpawnLimit();
++                    break;
++                case CREATURE:
++                    spawnThisTick = spawnAnimalThisTick;
++                    limit = worldserver.getWorld().getAnimalSpawnLimit();
++                    break;
++                case WATER_CREATURE:
++                    spawnThisTick = spawnWaterThisTick;
++                    limit = worldserver.getWorld().getWaterAnimalSpawnLimit();
++                    break;
++                case AMBIENT:
++                    spawnThisTick = spawnAmbientThisTick;
++                    limit = worldserver.getWorld().getAmbientSpawnLimit();
++                    break;
++                case WATER_AMBIENT:
++                    spawnThisTick = spawnWaterAmbientThisTick;
++                    limit = worldserver.getWorld().getWaterAmbientSpawnLimit();
++                    break;
++            }
+ 
+-            if ((flag || !enumcreaturetype.d()) && (flag1 || enumcreaturetype.d()) && (flag2 || !enumcreaturetype.e()) && spawnercreature_d.a(enumcreaturetype)) {
++            if (!spawnThisTick || limit == 0) {
++                continue;
++            }
++
++            if ((flag || !enumcreaturetype.d()) && (flag1 || enumcreaturetype.d()) && (flag2 || !enumcreaturetype.e()) && spawnercreature_d.a(enumcreaturetype, limit)) {
++                // CraftBukkit end
+                 a(enumcreaturetype, worldserver, chunk, (entitytypes, blockposition, ichunkaccess) -> {
+                     return spawnercreature_d.a(entitytypes, blockposition, ichunkaccess);
+                 }, (entityinsentient, ichunkaccess) -> {
+@@ -147,10 +191,14 @@
+                                         entityinsentient.setPositionRotation(d0, (double) i, d1, worldserver.random.nextFloat() * 360.0F, 0.0F);
+                                         if (a(worldserver, entityinsentient, d2)) {
+                                             groupdataentity = entityinsentient.prepare(worldserver, worldserver.getDamageScaler(entityinsentient.getChunkCoordinates()), EnumMobSpawn.NATURAL, groupdataentity, (NBTTagCompound) null);
+-                                            ++j;
+-                                            ++k1;
+-                                            worldserver.addAllEntities(entityinsentient);
+-                                            spawnercreature_a.run(entityinsentient, ichunkaccess);
++                                            // CraftBukkit start
++                                            worldserver.addAllEntities(entityinsentient, SpawnReason.NATURAL);
++                                            if (!entityinsentient.dead) {
++                                                ++j;
++                                                ++k1;
++                                                spawnercreature_a.run(entityinsentient, ichunkaccess);
++                                            }
++                                            // CraftBukkit end
+                                             if (j >= entityinsentient.getMaxSpawnGroup()) {
+                                                 return;
+                                             }
+@@ -333,7 +381,7 @@
+ 
+                                 if (entityinsentient.a((GeneratorAccess) worldaccess, EnumMobSpawn.CHUNK_GENERATION) && entityinsentient.a((IWorldReader) worldaccess)) {
+                                     groupdataentity = entityinsentient.prepare(worldaccess, worldaccess.getDamageScaler(entityinsentient.getChunkCoordinates()), EnumMobSpawn.CHUNK_GENERATION, groupdataentity, (NBTTagCompound) null);
+-                                    worldaccess.addAllEntities(entityinsentient);
++                                    worldaccess.addAllEntities(entityinsentient, SpawnReason.CHUNK_GEN); // CraftBukkit
+                                     flag = true;
+                                 }
+                             }
+@@ -456,8 +504,10 @@
+             return this.d;
+         }
+ 
+-        private boolean a(EnumCreatureType enumcreaturetype) {
+-            int i = enumcreaturetype.c() * this.a / SpawnerCreature.b;
++        // CraftBukkit start
++        private boolean a(EnumCreatureType enumcreaturetype, int limit) {
++            int i = limit * this.a / SpawnerCreature.b;
++            // CraftBukkit end
+ 
+             return this.b.getInt(enumcreaturetype) < i;
+         }

paper-server/nms-patches/net/minecraft/world/level/TickListServer.patch

@@ -0,0 +1,31 @@
+--- a/net/minecraft/server/TickListServer.java
++++ b/net/minecraft/server/TickListServer.java
+@@ -36,11 +36,17 @@
+     public void b() {
+         int i = this.nextTickList.size();
+ 
+-        if (i != this.nextTickListHash.size()) {
++        if (false) { // CraftBukkit
+             throw new IllegalStateException("TickNextTick list out of synch");
+         } else {
+             if (i > 65536) {
+-                i = 65536;
++                // CraftBukkit start - If the server has too much to process over time, try to alleviate that
++                if (i > 20 * 65536) {
++                    i = i / 20;
++                } else {
++                    i = 65536;
++                }
++                // CraftBukkit end
+             }
+ 
+             ChunkProviderServer chunkproviderserver = this.e.getChunkProvider();
+@@ -79,7 +85,7 @@
+                         throw new ReportedException(crashreport);
+                     }
+                 } else {
+-                    this.a(nextticklistentry.a, nextticklistentry.b(), 0);
++                    this.a(nextticklistentry.a, (T) nextticklistentry.b(), 0); // CraftBukkit - decompile error
+                 }
+             }
+ 

paper-server/nms-patches/net/minecraft/world/level/World.patch

@@ -0,0 +1,347 @@
+--- a/net/minecraft/server/World.java
++++ b/net/minecraft/server/World.java
+@@ -14,6 +14,17 @@
+ import org.apache.logging.log4j.LogManager;
+ import org.apache.logging.log4j.Logger;
+ 
++// CraftBukkit start
++import java.util.HashMap;
++import java.util.Map;
++import org.bukkit.Bukkit;
++import org.bukkit.craftbukkit.CraftServer;
++import org.bukkit.craftbukkit.CraftWorld;
++import org.bukkit.craftbukkit.block.CapturedBlockState;
++import org.bukkit.craftbukkit.block.data.CraftBlockData;
++import org.bukkit.event.block.BlockPhysicsEvent;
++// CraftBukkit end
++
+ public abstract class World implements GeneratorAccess, AutoCloseable {
+ 
+     protected static final Logger LOGGER = LogManager.getLogger();
+@@ -45,7 +56,49 @@
+     private final BiomeManager biomeManager;
+     private final ResourceKey<World> dimensionKey;
+ 
+-    protected World(WorldDataMutable worlddatamutable, ResourceKey<World> resourcekey, final DimensionManager dimensionmanager, Supplier<GameProfilerFiller> supplier, boolean flag, boolean flag1, long i) {
++    // CraftBukkit start Added the following
++    private final ResourceKey<DimensionManager> typeKey;
++    private final CraftWorld world;
++    public boolean pvpMode;
++    public boolean keepSpawnInMemory = true;
++    public org.bukkit.generator.ChunkGenerator generator;
++
++    public boolean captureBlockStates = false;
++    public boolean captureTreeGeneration = false;
++    public Map<BlockPosition, CapturedBlockState> capturedBlockStates = new java.util.LinkedHashMap<>();
++    public Map<BlockPosition, TileEntity> capturedTileEntities = new HashMap<>();
++    public List<EntityItem> captureDrops;
++    public long ticksPerAnimalSpawns;
++    public long ticksPerMonsterSpawns;
++    public long ticksPerWaterSpawns;
++    public long ticksPerWaterAmbientSpawns;
++    public long ticksPerAmbientSpawns;
++    public boolean populating;
++
++    public CraftWorld getWorld() {
++        return this.world;
++    }
++
++    public CraftServer getServer() {
++        return (CraftServer) Bukkit.getServer();
++    }
++
++    public ResourceKey<DimensionManager> getTypeKey() {
++        return typeKey;
++    }
++
++    protected World(WorldDataMutable worlddatamutable, ResourceKey<World> resourcekey, final DimensionManager dimensionmanager, Supplier<GameProfilerFiller> supplier, boolean flag, boolean flag1, long i, org.bukkit.generator.ChunkGenerator gen, org.bukkit.World.Environment env) {
++        this.generator = gen;
++        this.world = new CraftWorld((WorldServer) this, gen, env);
++        this.ticksPerAnimalSpawns = this.getServer().getTicksPerAnimalSpawns(); // CraftBukkit
++        this.ticksPerMonsterSpawns = this.getServer().getTicksPerMonsterSpawns(); // CraftBukkit
++        this.ticksPerWaterSpawns = this.getServer().getTicksPerWaterSpawns(); // CraftBukkit
++        this.ticksPerWaterAmbientSpawns = this.getServer().getTicksPerWaterAmbientSpawns(); // CraftBukkit
++        this.ticksPerAmbientSpawns = this.getServer().getTicksPerAmbientSpawns(); // CraftBukkit
++        this.typeKey = (ResourceKey) this.getServer().getHandle().getServer().customRegistry.a().c(dimensionmanager).orElseThrow(() -> {
++            return new IllegalStateException("Unregistered dimension type: " + dimensionmanager);
++        });
++        // CraftBukkit end
+         this.methodProfiler = supplier;
+         this.worldData = worlddatamutable;
+         this.x = dimensionmanager;
+@@ -55,12 +108,12 @@
+             this.worldBorder = new WorldBorder() {
+                 @Override
+                 public double getCenterX() {
+-                    return super.getCenterX() / dimensionmanager.getCoordinateScale();
++                    return super.getCenterX(); // CraftBukkit
+                 }
+ 
+                 @Override
+                 public double getCenterZ() {
+-                    return super.getCenterZ() / dimensionmanager.getCoordinateScale();
++                    return super.getCenterZ(); // CraftBukkit
+                 }
+             };
+         } else {
+@@ -70,6 +123,35 @@
+         this.serverThread = Thread.currentThread();
+         this.biomeManager = new BiomeManager(this, i, dimensionmanager.getGenLayerZoomer());
+         this.debugWorld = flag1;
++        // CraftBukkit start
++        getWorldBorder().world = (WorldServer) this;
++        // From PlayerList.setPlayerFileData
++        getWorldBorder().a(new IWorldBorderListener() {
++            public void a(WorldBorder worldborder, double d0) {
++                getServer().getHandle().sendAll(new PacketPlayOutWorldBorder(worldborder, PacketPlayOutWorldBorder.EnumWorldBorderAction.SET_SIZE), worldborder.world);
++            }
++
++            public void a(WorldBorder worldborder, double d0, double d1, long i) {
++                getServer().getHandle().sendAll(new PacketPlayOutWorldBorder(worldborder, PacketPlayOutWorldBorder.EnumWorldBorderAction.LERP_SIZE), worldborder.world);
++            }
++
++            public void a(WorldBorder worldborder, double d0, double d1) {
++                getServer().getHandle().sendAll(new PacketPlayOutWorldBorder(worldborder, PacketPlayOutWorldBorder.EnumWorldBorderAction.SET_CENTER), worldborder.world);
++            }
++
++            public void a(WorldBorder worldborder, int i) {
++                getServer().getHandle().sendAll(new PacketPlayOutWorldBorder(worldborder, PacketPlayOutWorldBorder.EnumWorldBorderAction.SET_WARNING_TIME), worldborder.world);
++            }
++
++            public void b(WorldBorder worldborder, int i) {
++                getServer().getHandle().sendAll(new PacketPlayOutWorldBorder(worldborder, PacketPlayOutWorldBorder.EnumWorldBorderAction.SET_WARNING_BLOCKS), worldborder.world);
++            }
++
++            public void b(WorldBorder worldborder, double d0) {}
++
++            public void c(WorldBorder worldborder, double d0) {}
++        });
++        // CraftBukkit end
+     }
+ 
+     @Override
+@@ -133,6 +215,17 @@
+ 
+     @Override
+     public boolean a(BlockPosition blockposition, IBlockData iblockdata, int i, int j) {
++        // CraftBukkit start - tree generation
++        if (this.captureTreeGeneration) {
++            CapturedBlockState blockstate = capturedBlockStates.get(blockposition);
++            if (blockstate == null) {
++                blockstate = CapturedBlockState.getTreeBlockState(this, blockposition, i);
++                this.capturedBlockStates.put(blockposition.immutableCopy(), blockstate);
++            }
++            blockstate.setData(iblockdata);
++            return true;
++        }
++        // CraftBukkit end
+         if (isOutsideWorld(blockposition)) {
+             return false;
+         } else if (!this.isClientSide && this.isDebugWorld()) {
+@@ -140,9 +233,24 @@
+         } else {
+             Chunk chunk = this.getChunkAtWorldCoords(blockposition);
+             Block block = iblockdata.getBlock();
+-            IBlockData iblockdata1 = chunk.setType(blockposition, iblockdata, (i & 64) != 0);
++
++            // CraftBukkit start - capture blockstates
++            boolean captured = false;
++            if (this.captureBlockStates && !this.capturedBlockStates.containsKey(blockposition)) {
++                CapturedBlockState blockstate = CapturedBlockState.getBlockState(this, blockposition, i);
++                this.capturedBlockStates.put(blockposition.immutableCopy(), blockstate);
++                captured = true;
++            }
++            // CraftBukkit end
++
++            IBlockData iblockdata1 = chunk.setType(blockposition, iblockdata, (i & 64) != 0, (i & 1024) == 0); // CraftBukkit custom NO_PLACE flag
+ 
+             if (iblockdata1 == null) {
++                // CraftBukkit start - remove blockstate if failed (or the same)
++                if (this.captureBlockStates && captured) {
++                    this.capturedBlockStates.remove(blockposition);
++                }
++                // CraftBukkit end
+                 return false;
+             } else {
+                 IBlockData iblockdata2 = this.getType(blockposition);
+@@ -153,6 +261,7 @@
+                     this.getMethodProfiler().exit();
+                 }
+ 
++                /*
+                 if (iblockdata2 == iblockdata) {
+                     if (iblockdata1 != iblockdata2) {
+                         this.b(blockposition, iblockdata1, iblockdata2);
+@@ -179,12 +288,65 @@
+ 
+                     this.a(blockposition, iblockdata1, iblockdata2);
+                 }
++                */
++
++                // CraftBukkit start
++                if (!this.captureBlockStates) { // Don't notify clients or update physics while capturing blockstates
++                    // Modularize client and physic updates
++                    notifyAndUpdatePhysics(blockposition, chunk, iblockdata1, iblockdata, iblockdata2, i, j);
++                }
++                // CraftBukkit end
+ 
+                 return true;
+             }
+         }
+     }
+ 
++    // CraftBukkit start - Split off from above in order to directly send client and physic updates
++    public void notifyAndUpdatePhysics(BlockPosition blockposition, Chunk chunk, IBlockData oldBlock, IBlockData newBlock, IBlockData actualBlock, int i, int j) {
++        IBlockData iblockdata = newBlock;
++        IBlockData iblockdata1 = oldBlock;
++        IBlockData iblockdata2 = actualBlock;
++        if (iblockdata2 == iblockdata) {
++            if (iblockdata1 != iblockdata2) {
++                this.b(blockposition, iblockdata1, iblockdata2);
++            }
++
++            if ((i & 2) != 0 && (!this.isClientSide || (i & 4) == 0) && (this.isClientSide || chunk == null || (chunk.getState() != null && chunk.getState().isAtLeast(PlayerChunk.State.TICKING)))) { // allow chunk to be null here as chunk.isReady() is false when we send our notification during block placement
++                this.notify(blockposition, iblockdata1, iblockdata, i);
++            }
++
++            if ((i & 1) != 0) {
++                this.update(blockposition, iblockdata1.getBlock());
++                if (!this.isClientSide && iblockdata.isComplexRedstone()) {
++                    this.updateAdjacentComparators(blockposition, newBlock.getBlock());
++                }
++            }
++
++            if ((i & 16) == 0 && j > 0) {
++                int k = i & -34;
++
++                // CraftBukkit start
++                iblockdata1.b(this, blockposition, k, j - 1); // Don't call an event for the old block to limit event spam
++                CraftWorld world = ((WorldServer) this).getWorld();
++                if (world != null) {
++                    BlockPhysicsEvent event = new BlockPhysicsEvent(world.getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()), CraftBlockData.fromData(iblockdata));
++                    this.getServer().getPluginManager().callEvent(event);
++
++                    if (event.isCancelled()) {
++                        return;
++                    }
++                }
++                // CraftBukkit end
++                iblockdata.a((GeneratorAccess) this, blockposition, k, j - 1);
++                iblockdata.b(this, blockposition, k, j - 1);
++            }
++
++            this.a(blockposition, iblockdata1, iblockdata2);
++        }
++    }
++    // CraftBukkit end
++
+     public void a(BlockPosition blockposition, IBlockData iblockdata, IBlockData iblockdata1) {}
+ 
+     @Override
+@@ -266,6 +428,17 @@
+             IBlockData iblockdata = this.getType(blockposition);
+ 
+             try {
++                // CraftBukkit start
++                CraftWorld world = ((WorldServer) this).getWorld();
++                if (world != null) {
++                    BlockPhysicsEvent event = new BlockPhysicsEvent(world.getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()), CraftBlockData.fromData(iblockdata), world.getBlockAt(blockposition1.getX(), blockposition1.getY(), blockposition1.getZ()));
++                    this.getServer().getPluginManager().callEvent(event);
++
++                    if (event.isCancelled()) {
++                        return;
++                    }
++                }
++                // CraftBukkit end
+                 iblockdata.doPhysics(this, blockposition, block, blockposition1, false);
+             } catch (Throwable throwable) {
+                 CrashReport crashreport = CrashReport.a(throwable, "Exception while updating neighbours");
+@@ -308,6 +481,14 @@
+ 
+     @Override
+     public IBlockData getType(BlockPosition blockposition) {
++        // CraftBukkit start - tree generation
++        if (captureTreeGeneration) {
++            CapturedBlockState previous = capturedBlockStates.get(blockposition);
++            if (previous != null) {
++                return previous.getHandle();
++            }
++        }
++        // CraftBukkit end
+         if (isOutsideWorld(blockposition)) {
+             return Blocks.VOID_AIR.getBlockData();
+         } else {
+@@ -455,9 +636,11 @@
+                 TileEntity tileentity1 = (TileEntity) this.tileEntityListPending.get(i);
+ 
+                 if (!tileentity1.isRemoved()) {
++                    /* CraftBukkit start - Order matters, moved down
+                     if (!this.tileEntityList.contains(tileentity1)) {
+                         this.a(tileentity1);
+                     }
++                    // CraftBukkit end */
+ 
+                     if (this.isLoaded(tileentity1.getPosition())) {
+                         Chunk chunk = this.getChunkAtWorldCoords(tileentity1.getPosition());
+@@ -465,6 +648,12 @@
+ 
+                         chunk.setTileEntity(tileentity1.getPosition(), tileentity1);
+                         this.notify(tileentity1.getPosition(), iblockdata, iblockdata, 3);
++                        // CraftBukkit start
++                        // From above, don't screw this up - SPIGOT-1746
++                        if (!this.tileEntityList.contains(tileentity1)) {
++                            this.a(tileentity1);
++                        }
++                        // CraftBukkit end
+                     }
+                 }
+             }
+@@ -509,12 +698,25 @@
+ 
+     @Nullable
+     @Override
++    // CraftBukkit start
+     public TileEntity getTileEntity(BlockPosition blockposition) {
++        return getTileEntity(blockposition, true);
++    }
++
++    @Nullable
++    protected TileEntity getTileEntity(BlockPosition blockposition, boolean validate) {
++        // CraftBukkit end
+         if (isOutsideWorld(blockposition)) {
+             return null;
+         } else if (!this.isClientSide && Thread.currentThread() != this.serverThread) {
+             return null;
+         } else {
++            // CraftBukkit start
++            if (capturedTileEntities.containsKey(blockposition)) {
++                return capturedTileEntities.get(blockposition);
++            }
++            // CraftBukkit end
++
+             TileEntity tileentity = null;
+ 
+             if (this.tickingTileEntities) {
+@@ -549,6 +751,13 @@
+     public void setTileEntity(BlockPosition blockposition, @Nullable TileEntity tileentity) {
+         if (!isOutsideWorld(blockposition)) {
+             if (tileentity != null && !tileentity.isRemoved()) {
++                // CraftBukkit start
++                if (captureBlockStates) {
++                    tileentity.setLocation(this, blockposition);
++                    capturedTileEntities.put(blockposition.immutableCopy(), tileentity);
++                    return;
++                }
++                // CraftBukkit end
+                 if (this.tickingTileEntities) {
+                     tileentity.setLocation(this, blockposition);
+                     Iterator iterator = this.tileEntityListPending.iterator();
+@@ -573,7 +782,7 @@
+     }
+ 
+     public void removeTileEntity(BlockPosition blockposition) {
+-        TileEntity tileentity = this.getTileEntity(blockposition);
++        TileEntity tileentity = this.getTileEntity(blockposition, false); // CraftBukkit
+ 
+         if (tileentity != null && this.tickingTileEntities) {
+             tileentity.al_();

paper-server/nms-patches/net/minecraft/world/level/WorldAccess.patch

@@ -0,0 +1,16 @@
+--- a/net/minecraft/server/WorldAccess.java
++++ b/net/minecraft/server/WorldAccess.java
+@@ -5,6 +5,12 @@
+     WorldServer getMinecraftWorld();
+ 
+     default void addAllEntities(Entity entity) {
+-        entity.recursiveStream().forEach(this::addEntity);
++        // CraftBukkit start
++        this.addAllEntities(entity, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.DEFAULT);
+     }
++
++    default void addAllEntities(Entity entity, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason reason) {
++        entity.recursiveStream().forEach((e) -> this.addEntity(e, reason));
++    }
++    // CraftBukkit end
+ }

paper-server/nms-patches/net/minecraft/world/level/block/Block.patch

@@ -0,0 +1,39 @@
+--- a/net/minecraft/server/Block.java
++++ b/net/minecraft/server/Block.java
+@@ -209,7 +209,13 @@
+             EntityItem entityitem = new EntityItem(world, (double) blockposition.getX() + d0, (double) blockposition.getY() + d1, (double) blockposition.getZ() + d2, itemstack);
+ 
+             entityitem.defaultPickupDelay();
+-            world.addEntity(entityitem);
++            // CraftBukkit start
++            if (world.captureDrops != null) {
++                world.captureDrops.add(entityitem);
++            } else {
++                world.addEntity(entityitem);
++            }
++            // CraftBukkit end
+         }
+     }
+ 
+@@ -240,7 +246,7 @@
+ 
+     public void a(World world, EntityHuman entityhuman, BlockPosition blockposition, IBlockData iblockdata, @Nullable TileEntity tileentity, ItemStack itemstack) {
+         entityhuman.b(StatisticList.BLOCK_MINED.b(this));
+-        entityhuman.applyExhaustion(0.005F);
++        entityhuman.applyExhaustion(0.005F, org.bukkit.event.entity.EntityExhaustionEvent.ExhaustionReason.BLOCK_MINED); // CraftBukkit - EntityExhaustionEvent
+         dropItems(iblockdata, world, blockposition, tileentity, entityhuman, itemstack);
+     }
+ 
+@@ -336,6 +342,12 @@
+         return this;
+     }
+ 
++    // CraftBukkit start
++    public int getExpDrop(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, ItemStack itemstack) {
++        return 0;
++    }
++    // CraftBukkit end
++
+     public static final class a {
+ 
+         private final IBlockData a;

paper-server/nms-patches/net/minecraft/world/level/block/BlockBamboo.patch

@@ -0,0 +1,39 @@
+--- a/net/minecraft/server/BlockBamboo.java
++++ b/net/minecraft/server/BlockBamboo.java
+@@ -170,14 +170,18 @@
+         BlockPosition blockposition1 = blockposition.down(2);
+         IBlockData iblockdata2 = world.getType(blockposition1);
+         BlockPropertyBambooSize blockpropertybamboosize = BlockPropertyBambooSize.NONE;
++        boolean shouldUpdateOthers = false; // CraftBukkit
+ 
+         if (i >= 1) {
+             if (iblockdata1.a(Blocks.BAMBOO) && iblockdata1.get(BlockBamboo.e) != BlockPropertyBambooSize.NONE) {
+                 if (iblockdata1.a(Blocks.BAMBOO) && iblockdata1.get(BlockBamboo.e) != BlockPropertyBambooSize.NONE) {
+                     blockpropertybamboosize = BlockPropertyBambooSize.LARGE;
+                     if (iblockdata2.a(Blocks.BAMBOO)) {
+-                        world.setTypeAndData(blockposition.down(), (IBlockData) iblockdata1.set(BlockBamboo.e, BlockPropertyBambooSize.SMALL), 3);
+-                        world.setTypeAndData(blockposition1, (IBlockData) iblockdata2.set(BlockBamboo.e, BlockPropertyBambooSize.NONE), 3);
++                        // CraftBukkit start - moved down
++                        // world.setTypeAndData(blockposition.down(), (IBlockData) iblockdata1.set(BlockBamboo.e, BlockPropertyBambooSize.SMALL), 3);
++                        // world.setTypeAndData(blockposition1, (IBlockData) iblockdata2.set(BlockBamboo.e, BlockPropertyBambooSize.NONE), 3);
++                        shouldUpdateOthers = true;
++                        // CraftBukkit end
+                     }
+                 }
+             } else {
+@@ -188,7 +192,14 @@
+         int j = (Integer) iblockdata.get(BlockBamboo.d) != 1 && !iblockdata2.a(Blocks.BAMBOO) ? 0 : 1;
+         int k = (i < 11 || random.nextFloat() >= 0.25F) && i != 15 ? 0 : 1;
+ 
+-        world.setTypeAndData(blockposition.up(), (IBlockData) ((IBlockData) ((IBlockData) this.getBlockData().set(BlockBamboo.d, j)).set(BlockBamboo.e, blockpropertybamboosize)).set(BlockBamboo.f, k), 3);
++        // CraftBukkit start
++        if (org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(world, blockposition, blockposition.up(), (IBlockData) ((IBlockData) ((IBlockData) this.getBlockData().set(BlockBamboo.d, j)).set(BlockBamboo.e, blockpropertybamboosize)).set(BlockBamboo.f, k), 3)) {
++            if (shouldUpdateOthers) {
++                world.setTypeAndData(blockposition.down(), (IBlockData) iblockdata1.set(BlockBamboo.e, BlockPropertyBambooSize.SMALL), 3);
++                world.setTypeAndData(blockposition1, (IBlockData) iblockdata2.set(BlockBamboo.e, BlockPropertyBambooSize.NONE), 3);
++            }
++        }
++        // CraftBukkit end
+     }
+ 
+     protected int a(IBlockAccess iblockaccess, BlockPosition blockposition) {

paper-server/nms-patches/net/minecraft/world/level/block/BlockBambooSapling.patch

@@ -0,0 +1,10 @@
+--- a/net/minecraft/server/BlockBambooSapling.java
++++ b/net/minecraft/server/BlockBambooSapling.java
+@@ -69,6 +69,6 @@
+     }
+ 
+     protected void a(World world, BlockPosition blockposition) {
+-        world.setTypeAndData(blockposition.up(), (IBlockData) Blocks.BAMBOO.getBlockData().set(BlockBamboo.e, BlockPropertyBambooSize.SMALL), 3);
++        org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(world, blockposition, blockposition.up(), (IBlockData) Blocks.BAMBOO.getBlockData().set(BlockBamboo.e, BlockPropertyBambooSize.SMALL), 3); // CraftBukkit - BlockSpreadEvent
+     }
+ }

paper-server/nms-patches/net/minecraft/world/level/block/BlockBed.patch

@@ -0,0 +1,58 @@
+--- a/net/minecraft/server/BlockBed.java
++++ b/net/minecraft/server/BlockBed.java
+@@ -39,7 +39,8 @@
+                 }
+             }
+ 
+-            if (!a(world)) {
++            // CraftBukkit - moved world and biome check into EntityHuman
++            if (false && !a(world)) {
+                 world.a(blockposition, false);
+                 BlockPosition blockposition1 = blockposition.shift(((EnumDirection) iblockdata.get(BlockBed.FACING)).opposite());
+ 
+@@ -56,7 +57,16 @@
+ 
+                 return EnumInteractionResult.SUCCESS;
+             } else {
++                // CraftBukkit start
++                IBlockData finaliblockdata = iblockdata;
++                BlockPosition finalblockposition = blockposition;
++                // CraftBukkit end
+                 entityhuman.sleep(blockposition).ifLeft((entityhuman_enumbedresult) -> {
++                    // CraftBukkit start - handling bed explosion from below here
++                    if (entityhuman_enumbedresult == EntityHuman.EnumBedResult.NOT_POSSIBLE_HERE) {
++                        this.explodeBed(finaliblockdata, world, finalblockposition);
++                    } else
++                    // CraftBukkit end
+                     if (entityhuman_enumbedresult != null) {
+                         entityhuman.a(entityhuman_enumbedresult.a(), true);
+                     }
+@@ -67,8 +77,27 @@
+         }
+     }
+ 
++    // CraftBukkit start
++    private EnumInteractionResult explodeBed(IBlockData iblockdata, World world, BlockPosition blockposition) {
++        {
++            {
++                world.a(blockposition, false);
++                BlockPosition blockposition1 = blockposition.shift(((EnumDirection) iblockdata.get(BlockBed.FACING)).opposite());
++
++                if (world.getType(blockposition1).getBlock() == this) {
++                    world.a(blockposition1, false);
++                }
++
++                world.createExplosion((Entity) null, DamageSource.a(), (ExplosionDamageCalculator) null, (double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 0.5D, (double) blockposition.getZ() + 0.5D, 5.0F, true, Explosion.Effect.DESTROY);
++                return EnumInteractionResult.SUCCESS;
++            }
++        }
++    }
++    // CraftBukkit end
++
+     public static boolean a(World world) {
+-        return world.getDimensionManager().isBedWorks();
++        // CraftBukkit - moved world and biome check into EntityHuman
++        return true || world.getDimensionManager().isBedWorks();
+     }
+ 
+     private boolean a(World world, BlockPosition blockposition) {

paper-server/nms-patches/net/minecraft/world/level/block/BlockBeehive.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/server/BlockBeehive.java
++++ b/net/minecraft/server/BlockBeehive.java
+@@ -55,7 +55,7 @@
+                 EntityBee entitybee = (EntityBee) iterator.next();
+ 
+                 if (entitybee.getGoalTarget() == null) {
+-                    entitybee.setGoalTarget((EntityLiving) list1.get(world.random.nextInt(i)));
++                    entitybee.setGoalTarget((EntityLiving) list1.get(world.random.nextInt(i)), org.bukkit.event.entity.EntityTargetEvent.TargetReason.CLOSEST_PLAYER, true); // CraftBukkit
+                 }
+             }
+         }

paper-server/nms-patches/net/minecraft/world/level/block/BlockButtonAbstract.patch

@@ -0,0 +1,96 @@
+--- a/net/minecraft/server/BlockButtonAbstract.java
++++ b/net/minecraft/server/BlockButtonAbstract.java
+@@ -4,6 +4,11 @@
+ import java.util.Random;
+ import javax.annotation.Nullable;
+ 
++// CraftBukkit start
++import org.bukkit.event.block.BlockRedstoneEvent;
++import org.bukkit.event.entity.EntityInteractEvent;
++// CraftBukkit end
++
+ public abstract class BlockButtonAbstract extends BlockAttachable {
+ 
+     public static final BlockStateBoolean POWERED = BlockProperties.w;
+@@ -70,6 +75,19 @@
+         if ((Boolean) iblockdata.get(BlockButtonAbstract.POWERED)) {
+             return EnumInteractionResult.CONSUME;
+         } else {
++            // CraftBukkit start
++            boolean powered = ((Boolean) iblockdata.get(POWERED));
++            org.bukkit.block.Block block = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
++            int old = (powered) ? 15 : 0;
++            int current = (!powered) ? 15 : 0;
++
++            BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(block, old, current);
++            world.getServer().getPluginManager().callEvent(eventRedstone);
++
++            if ((eventRedstone.getNewCurrent() > 0) != (!powered)) {
++                return EnumInteractionResult.SUCCESS;
++            }
++            // CraftBukkit end
+             this.d(iblockdata, world, blockposition);
+             this.a(entityhuman, world, blockposition, true);
+             return EnumInteractionResult.a(world.isClientSide);
+@@ -120,6 +138,16 @@
+             if (this.v) {
+                 this.e(iblockdata, (World) worldserver, blockposition);
+             } else {
++                // CraftBukkit start
++                org.bukkit.block.Block block = worldserver.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
++
++                BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(block, 15, 0);
++                worldserver.getServer().getPluginManager().callEvent(eventRedstone);
++
++                if (eventRedstone.getNewCurrent() > 0) {
++                    return;
++                }
++                // CraftBukkit end
+                 worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockButtonAbstract.POWERED, false), 3);
+                 this.f(iblockdata, (World) worldserver, blockposition);
+                 this.a((EntityHuman) null, worldserver, blockposition, false);
+@@ -140,7 +168,44 @@
+         boolean flag = !list.isEmpty();
+         boolean flag1 = (Boolean) iblockdata.get(BlockButtonAbstract.POWERED);
+ 
++        // CraftBukkit start - Call interact event when arrows turn on wooden buttons
++        if (flag1 != flag && flag) {
++            org.bukkit.block.Block block = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
++            boolean allowed = false;
++
++            // If all of the events are cancelled block the button press, else allow
++            for (Object object : list) {
++                if (object != null) {
++                    EntityInteractEvent event = new EntityInteractEvent(((Entity) object).getBukkitEntity(), block);
++                    world.getServer().getPluginManager().callEvent(event);
++
++                    if (!event.isCancelled()) {
++                        allowed = true;
++                        break;
++                    }
++                }
++            }
++
++            if (!allowed) {
++                return;
++            }
++        }
++        // CraftBukkit end
++
+         if (flag != flag1) {
++            // CraftBukkit start
++            boolean powered = flag1;
++            org.bukkit.block.Block block = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
++            int old = (powered) ? 15 : 0;
++            int current = (!powered) ? 15 : 0;
++
++            BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(block, old, current);
++            world.getServer().getPluginManager().callEvent(eventRedstone);
++
++            if ((flag && eventRedstone.getNewCurrent() <= 0) || (!flag && eventRedstone.getNewCurrent() > 0)) {
++                return;
++            }
++            // CraftBukkit end
+             world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockButtonAbstract.POWERED, flag), 3);
+             this.f(iblockdata, world, blockposition);
+             this.a((EntityHuman) null, world, blockposition, flag);

paper-server/nms-patches/net/minecraft/world/level/block/BlockCactus.patch

@@ -0,0 +1,30 @@
+--- a/net/minecraft/server/BlockCactus.java
++++ b/net/minecraft/server/BlockCactus.java
+@@ -3,6 +3,8 @@
+ import java.util.Iterator;
+ import java.util.Random;
+ 
++import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
++
+ public class BlockCactus extends Block {
+ 
+     public static final BlockStateInteger AGE = BlockProperties.aj;
+@@ -37,7 +39,7 @@
+                 int j = (Integer) iblockdata.get(BlockCactus.AGE);
+ 
+                 if (j == 15) {
+-                    worldserver.setTypeUpdate(blockposition1, this.getBlockData());
++                    CraftEventFactory.handleBlockGrowEvent(worldserver, blockposition1, this.getBlockData()); // CraftBukkit
+                     IBlockData iblockdata1 = (IBlockData) iblockdata.set(BlockCactus.AGE, 0);
+ 
+                     worldserver.setTypeAndData(blockposition, iblockdata1, 4);
+@@ -94,7 +96,9 @@
+ 
+     @Override
+     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
++        CraftEventFactory.blockDamage = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()); // CraftBukkit
+         entity.damageEntity(DamageSource.CACTUS, 1.0F);
++        CraftEventFactory.blockDamage = null; // CraftBukkit
+     }
+ 
+     @Override

paper-server/nms-patches/net/minecraft/world/level/block/BlockCake.patch

@@ -0,0 +1,22 @@
+--- a/net/minecraft/server/BlockCake.java
++++ b/net/minecraft/server/BlockCake.java
+@@ -37,7 +37,18 @@
+             return EnumInteractionResult.PASS;
+         } else {
+             entityhuman.a(StatisticList.EAT_CAKE_SLICE);
+-            entityhuman.getFoodData().eat(2, 0.1F);
++            // CraftBukkit start
++            // entityhuman.getFoodData().eat(2, 0.1F);
++            int oldFoodLevel = entityhuman.getFoodData().foodLevel;
++
++            org.bukkit.event.entity.FoodLevelChangeEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callFoodLevelChangeEvent(entityhuman, 2 + oldFoodLevel);
++
++            if (!event.isCancelled()) {
++                entityhuman.getFoodData().eat(event.getFoodLevel() - oldFoodLevel, 0.1F);
++            }
++
++            ((EntityPlayer) entityhuman).getBukkitEntity().sendHealthUpdate();
++            // CraftBukkit end
+             int i = (Integer) iblockdata.get(BlockCake.BITES);
+ 
+             if (i < 6) {

paper-server/nms-patches/net/minecraft/world/level/block/BlockCampfire.patch

@@ -0,0 +1,14 @@
+--- a/net/minecraft/server/BlockCampfire.java
++++ b/net/minecraft/server/BlockCampfire.java
+@@ -144,6 +144,11 @@
+             if (flag && !(Boolean) iblockdata.get(BlockCampfire.LIT) && !(Boolean) iblockdata.get(BlockCampfire.d)) {
+                 BlockPosition blockposition = movingobjectpositionblock.getBlockPosition();
+ 
++                // CraftBukkit start
++                if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockIgniteEvent(world, blockposition, iprojectile).isCancelled()) {
++                    return;
++                }
++                // CraftBukkit end
+                 world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockProperties.r, true), 11);
+             }
+         }

paper-server/nms-patches/net/minecraft/world/level/block/BlockCauldron.patch

@@ -0,0 +1,175 @@
+--- a/net/minecraft/server/BlockCauldron.java
++++ b/net/minecraft/server/BlockCauldron.java
+@@ -1,5 +1,7 @@
+ package net.minecraft.server;
+ 
++import org.bukkit.event.block.CauldronLevelChangeEvent; // CraftBukkit
++
+ public class BlockCauldron extends Block {
+ 
+     public static final BlockStateInteger LEVEL = BlockProperties.ar;
+@@ -27,8 +29,13 @@
+         float f = (float) blockposition.getY() + (6.0F + (float) (3 * i)) / 16.0F;
+ 
+         if (!world.isClientSide && entity.isBurning() && i > 0 && entity.locY() <= (double) f) {
++            // CraftBukkit start
++            if (!this.changeLevel(world, blockposition, iblockdata, i - 1, entity, CauldronLevelChangeEvent.ChangeReason.EXTINGUISH)) {
++                return;
++            }
+             entity.extinguish();
+-            this.a(world, blockposition, iblockdata, i - 1);
++            // this.a(world, blockposition, iblockdata, i - 1);
++            // CraftBukkit end
+         }
+ 
+     }
+@@ -45,18 +52,27 @@
+ 
+             if (item == Items.WATER_BUCKET) {
+                 if (i < 3 && !world.isClientSide) {
++                    // CraftBukkit start
++                    if (!this.changeLevel(world, blockposition, iblockdata, 3, entityhuman, CauldronLevelChangeEvent.ChangeReason.BUCKET_EMPTY)) {
++                        return EnumInteractionResult.SUCCESS;
++                    }
+                     if (!entityhuman.abilities.canInstantlyBuild) {
+                         entityhuman.a(enumhand, new ItemStack(Items.BUCKET));
+                     }
+ 
+                     entityhuman.a(StatisticList.FILL_CAULDRON);
+-                    this.a(world, blockposition, iblockdata, 3);
++                    // this.a(world, blockposition, iblockdata, 3);
++                    // CraftBukkit end
+                     world.playSound((EntityHuman) null, blockposition, SoundEffects.ITEM_BUCKET_EMPTY, SoundCategory.BLOCKS, 1.0F, 1.0F);
+                 }
+ 
+                 return EnumInteractionResult.a(world.isClientSide);
+             } else if (item == Items.BUCKET) {
+                 if (i == 3 && !world.isClientSide) {
++                    // CraftBukkit start
++                    if (!this.changeLevel(world, blockposition, iblockdata, 0, entityhuman, CauldronLevelChangeEvent.ChangeReason.BUCKET_FILL)) {
++                        return EnumInteractionResult.SUCCESS;
++                    }
+                     if (!entityhuman.abilities.canInstantlyBuild) {
+                         itemstack.subtract(1);
+                         if (itemstack.isEmpty()) {
+@@ -67,7 +83,8 @@
+                     }
+ 
+                     entityhuman.a(StatisticList.USE_CAULDRON);
+-                    this.a(world, blockposition, iblockdata, 0);
++                    // this.a(world, blockposition, iblockdata, 0);
++                    // CraftBukkit end
+                     world.playSound((EntityHuman) null, blockposition, SoundEffects.ITEM_BUCKET_FILL, SoundCategory.BLOCKS, 1.0F, 1.0F);
+                 }
+ 
+@@ -77,6 +94,10 @@
+ 
+                 if (item == Items.GLASS_BOTTLE) {
+                     if (i > 0 && !world.isClientSide) {
++                        // CraftBukkit start
++                        if (!this.changeLevel(world, blockposition, iblockdata, i - 1, entityhuman, CauldronLevelChangeEvent.ChangeReason.BOTTLE_FILL)) {
++                            return EnumInteractionResult.SUCCESS;
++                        }
+                         if (!entityhuman.abilities.canInstantlyBuild) {
+                             itemstack1 = PotionUtil.a(new ItemStack(Items.POTION), Potions.WATER);
+                             entityhuman.a(StatisticList.USE_CAULDRON);
+@@ -91,12 +112,17 @@
+                         }
+ 
+                         world.playSound((EntityHuman) null, blockposition, SoundEffects.ITEM_BOTTLE_FILL, SoundCategory.BLOCKS, 1.0F, 1.0F);
+-                        this.a(world, blockposition, iblockdata, i - 1);
++                        // this.a(world, blockposition, iblockdata, i - 1);
++                        // CraftBukkit end
+                     }
+ 
+                     return EnumInteractionResult.a(world.isClientSide);
+                 } else if (item == Items.POTION && PotionUtil.d(itemstack) == Potions.WATER) {
+                     if (i < 3 && !world.isClientSide) {
++                        // CraftBukkit start
++                        if (!this.changeLevel(world, blockposition, iblockdata, i + 1, entityhuman, CauldronLevelChangeEvent.ChangeReason.BOTTLE_EMPTY)) {
++                            return EnumInteractionResult.SUCCESS;
++                        }
+                         if (!entityhuman.abilities.canInstantlyBuild) {
+                             itemstack1 = new ItemStack(Items.GLASS_BOTTLE);
+                             entityhuman.a(StatisticList.USE_CAULDRON);
+@@ -107,7 +133,8 @@
+                         }
+ 
+                         world.playSound((EntityHuman) null, blockposition, SoundEffects.ITEM_BOTTLE_EMPTY, SoundCategory.BLOCKS, 1.0F, 1.0F);
+-                        this.a(world, blockposition, iblockdata, i + 1);
++                        // this.a(world, blockposition, iblockdata, i + 1);
++                        // CraftBukkit end
+                     }
+ 
+                     return EnumInteractionResult.a(world.isClientSide);
+@@ -116,8 +143,13 @@
+                         IDyeable idyeable = (IDyeable) item;
+ 
+                         if (idyeable.a(itemstack) && !world.isClientSide) {
++                            // CraftBukkit start
++                            if (!this.changeLevel(world, blockposition, iblockdata, i - 1, entityhuman, CauldronLevelChangeEvent.ChangeReason.ARMOR_WASH)) {
++                                return EnumInteractionResult.SUCCESS;
++                            }
+                             idyeable.c(itemstack);
+-                            this.a(world, blockposition, iblockdata, i - 1);
++                            // this.a(world, blockposition, iblockdata, i - 1);
++                            // CraftBukkit end
+                             entityhuman.a(StatisticList.CLEAN_ARMOR);
+                             return EnumInteractionResult.SUCCESS;
+                         }
+@@ -125,13 +157,18 @@
+ 
+                     if (i > 0 && item instanceof ItemBanner) {
+                         if (TileEntityBanner.b(itemstack) > 0 && !world.isClientSide) {
++                            // CraftBukkit start
++                            if (!this.changeLevel(world, blockposition, iblockdata, i - 1, entityhuman, CauldronLevelChangeEvent.ChangeReason.BANNER_WASH)) {
++                                return EnumInteractionResult.SUCCESS;
++                            }
+                             itemstack1 = itemstack.cloneItemStack();
+                             itemstack1.setCount(1);
+                             TileEntityBanner.c(itemstack1);
+                             entityhuman.a(StatisticList.CLEAN_BANNER);
+                             if (!entityhuman.abilities.canInstantlyBuild) {
+                                 itemstack.subtract(1);
+-                                this.a(world, blockposition, iblockdata, i - 1);
++                                // this.a(world, blockposition, iblockdata, i - 1);
++                                // CraftBukkit end
+                             }
+ 
+                             if (itemstack.isEmpty()) {
+@@ -169,9 +206,25 @@
+         }
+     }
+ 
++    // CraftBukkit start
+     public void a(World world, BlockPosition blockposition, IBlockData iblockdata, int i) {
+-        world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockCauldron.LEVEL, MathHelper.clamp(i, 0, 3)), 2);
++        this.changeLevel(world, blockposition, iblockdata, i, null, CauldronLevelChangeEvent.ChangeReason.UNKNOWN);
++    }
++
++    private boolean changeLevel(World world, BlockPosition blockposition, IBlockData iblockdata, int i, Entity entity, CauldronLevelChangeEvent.ChangeReason reason) {
++        int newLevel = Integer.valueOf(MathHelper.clamp(i, 0, 3));
++        CauldronLevelChangeEvent event = new CauldronLevelChangeEvent(
++                world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()),
++                (entity == null) ? null : entity.getBukkitEntity(), reason, iblockdata.get(BlockCauldron.LEVEL), newLevel
++        );
++        world.getServer().getPluginManager().callEvent(event);
++        if (event.isCancelled()) {
++            return false;
++        }
++        world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockCauldron.LEVEL, event.getNewLevel()), 2);
+         world.updateAdjacentComparators(blockposition, this);
++        return true;
++        // CraftBukkit end
+     }
+ 
+     @Override
+@@ -183,7 +236,7 @@
+                 IBlockData iblockdata = world.getType(blockposition);
+ 
+                 if ((Integer) iblockdata.get(BlockCauldron.LEVEL) < 3) {
+-                    world.setTypeAndData(blockposition, (IBlockData) iblockdata.a((IBlockState) BlockCauldron.LEVEL), 2);
++                    this.a(world, blockposition, (IBlockData) iblockdata.a((IBlockState) BlockCauldron.LEVEL), 2); // CraftBukkit
+                 }
+ 
+             }

paper-server/nms-patches/net/minecraft/world/level/block/BlockChest.patch

@@ -0,0 +1,76 @@
+--- a/net/minecraft/server/BlockChest.java
++++ b/net/minecraft/server/BlockChest.java
+@@ -35,24 +35,7 @@
+         public Optional<ITileInventory> a(final TileEntityChest tileentitychest, final TileEntityChest tileentitychest1) {
+             final InventoryLargeChest inventorylargechest = new InventoryLargeChest(tileentitychest, tileentitychest1);
+ 
+-            return Optional.of(new ITileInventory() {
+-                @Nullable
+-                @Override
+-                public Container createMenu(int i, PlayerInventory playerinventory, EntityHuman entityhuman) {
+-                    if (tileentitychest.e(entityhuman) && tileentitychest1.e(entityhuman)) {
+-                        tileentitychest.d(playerinventory.player);
+-                        tileentitychest1.d(playerinventory.player);
+-                        return ContainerChest.b(i, playerinventory, inventorylargechest);
+-                    } else {
+-                        return null;
+-                    }
+-                }
+-
+-                @Override
+-                public IChatBaseComponent getScoreboardDisplayName() {
+-                    return (IChatBaseComponent) (tileentitychest.hasCustomName() ? tileentitychest.getScoreboardDisplayName() : (tileentitychest1.hasCustomName() ? tileentitychest1.getScoreboardDisplayName() : new ChatMessage("container.chestDouble")));
+-                }
+-            });
++            return Optional.of(new DoubleInventory(tileentitychest, tileentitychest1, inventorylargechest)); // CraftBukkit
+         }
+ 
+         public Optional<ITileInventory> a(TileEntityChest tileentitychest) {
+@@ -65,6 +48,38 @@
+         }
+     };
+ 
++    // CraftBukkit start
++    public static class DoubleInventory implements ITileInventory {
++
++        private final TileEntityChest tileentitychest;
++        private final TileEntityChest tileentitychest1;
++        public final InventoryLargeChest inventorylargechest;
++
++        public DoubleInventory(TileEntityChest tileentitychest, TileEntityChest tileentitychest1, InventoryLargeChest inventorylargechest) {
++            this.tileentitychest = tileentitychest;
++            this.tileentitychest1 = tileentitychest1;
++            this.inventorylargechest = inventorylargechest;
++        }
++
++        @Nullable
++        @Override
++        public Container createMenu(int i, PlayerInventory playerinventory, EntityHuman entityhuman) {
++            if (tileentitychest.e(entityhuman) && tileentitychest1.e(entityhuman)) {
++                tileentitychest.d(playerinventory.player);
++                tileentitychest1.d(playerinventory.player);
++                return ContainerChest.b(i, playerinventory, inventorylargechest);
++            } else {
++                return null;
++            }
++        }
++
++        @Override
++        public IChatBaseComponent getScoreboardDisplayName() {
++            return (IChatBaseComponent) (tileentitychest.hasCustomName() ? tileentitychest.getScoreboardDisplayName() : (tileentitychest1.hasCustomName() ? tileentitychest1.getScoreboardDisplayName() : new ChatMessage("container.chestDouble")));
++        }
++    };
++    // CraftBukkit end
++
+     protected BlockChest(BlockBase.Info blockbase_info, Supplier<TileEntityTypes<? extends TileEntityChest>> supplier) {
+         super(blockbase_info, supplier);
+         this.j((IBlockData) ((IBlockData) ((IBlockData) ((IBlockData) this.blockStateList.getBlockData()).set(BlockChest.FACING, EnumDirection.NORTH)).set(BlockChest.c, BlockPropertyChestType.SINGLE)).set(BlockChest.d, false));
+@@ -218,7 +233,7 @@
+     }
+ 
+     public DoubleBlockFinder.Result<? extends TileEntityChest> a(IBlockData iblockdata, World world, BlockPosition blockposition, boolean flag) {
+-        BiPredicate bipredicate;
++        BiPredicate<GeneratorAccess, BlockPosition> bipredicate; // CraftBukkit - decompile error
+ 
+         if (flag) {
+             bipredicate = (generatoraccess, blockposition1) -> {

paper-server/nms-patches/net/minecraft/world/level/block/BlockChorusFlower.patch

@@ -0,0 +1,61 @@
+--- a/net/minecraft/server/BlockChorusFlower.java
++++ b/net/minecraft/server/BlockChorusFlower.java
+@@ -4,6 +4,8 @@
+ import java.util.Random;
+ import javax.annotation.Nullable;
+ 
++import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
++
+ public class BlockChorusFlower extends Block {
+ 
+     public static final BlockStateInteger AGE = BlockProperties.ah;
+@@ -68,8 +70,12 @@
+                 }
+ 
+                 if (flag && b((IWorldReader) worldserver, blockposition1, (EnumDirection) null) && worldserver.isEmpty(blockposition.up(2))) {
+-                    worldserver.setTypeAndData(blockposition, this.b.a((IBlockAccess) worldserver, blockposition), 2);
+-                    this.a(worldserver, blockposition1, i);
++                    // CraftBukkit start - add event
++                    if (CraftEventFactory.handleBlockSpreadEvent(worldserver, blockposition, blockposition1, this.getBlockData().set(BlockChorusFlower.AGE, Integer.valueOf(i)), 2)) {
++                        worldserver.setTypeAndData(blockposition, this.b.a((IBlockAccess) worldserver, blockposition), 2);
++                        this.a(worldserver, blockposition1, i);
++                    }
++                    // CraftBukkit end
+                 } else if (i < 4) {
+                     j = random.nextInt(4);
+                     if (flag1) {
+@@ -83,18 +89,30 @@
+                         BlockPosition blockposition2 = blockposition.shift(enumdirection);
+ 
+                         if (worldserver.isEmpty(blockposition2) && worldserver.isEmpty(blockposition2.down()) && b((IWorldReader) worldserver, blockposition2, enumdirection.opposite())) {
+-                            this.a(worldserver, blockposition2, i + 1);
+-                            flag2 = true;
++                            // CraftBukkit start - add event
++                            if (CraftEventFactory.handleBlockSpreadEvent(worldserver, blockposition, blockposition2, this.getBlockData().set(BlockChorusFlower.AGE, Integer.valueOf(i + 1)), 2)) {
++                                this.a(worldserver, blockposition2, i + 1);
++                                flag2 = true;
++                            }
++                            // CraftBukkit end
+                         }
+                     }
+ 
+                     if (flag2) {
+                         worldserver.setTypeAndData(blockposition, this.b.a((IBlockAccess) worldserver, blockposition), 2);
+                     } else {
+-                        this.a((World) worldserver, blockposition);
++                        // CraftBukkit - add event
++                        if (CraftEventFactory.handleBlockGrowEvent(worldserver, blockposition, this.getBlockData().set(BlockChorusFlower.AGE, Integer.valueOf(5)), 2)) {
++                            this.a((World) worldserver, blockposition);
++                        }
++                        // CraftBukkit end
+                     }
+                 } else {
+-                    this.a((World) worldserver, blockposition);
++                    // CraftBukkit - add event
++                    if (CraftEventFactory.handleBlockGrowEvent(worldserver, blockposition, this.getBlockData().set(BlockChorusFlower.AGE, Integer.valueOf(5)), 2)) {
++                        this.a((World) worldserver, blockposition);
++                    }
++                    // CraftBukkit end
+                 }
+ 
+             }

paper-server/nms-patches/net/minecraft/world/level/block/BlockCocoa.patch

@@ -0,0 +1,29 @@
+--- a/net/minecraft/server/BlockCocoa.java
++++ b/net/minecraft/server/BlockCocoa.java
+@@ -3,6 +3,8 @@
+ import java.util.Random;
+ import javax.annotation.Nullable;
+ 
++import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
++
+ public class BlockCocoa extends BlockFacingHorizontal implements IBlockFragilePlantElement {
+ 
+     public static final BlockStateInteger AGE = BlockProperties.af;
+@@ -27,7 +29,7 @@
+             int i = (Integer) iblockdata.get(BlockCocoa.AGE);
+ 
+             if (i < 2) {
+-                worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockCocoa.AGE, i + 1), 2);
++                CraftEventFactory.handleBlockGrowEvent(worldserver, blockposition, (IBlockData) iblockdata.set(BlockCocoa.AGE, i + 1), 2); // CraftBukkkit
+             }
+         }
+ 
+@@ -97,7 +99,7 @@
+ 
+     @Override
+     public void a(WorldServer worldserver, Random random, BlockPosition blockposition, IBlockData iblockdata) {
+-        worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockCocoa.AGE, (Integer) iblockdata.get(BlockCocoa.AGE) + 1), 2);
++        CraftEventFactory.handleBlockGrowEvent(worldserver, blockposition, (IBlockData) iblockdata.set(BlockCocoa.AGE, (Integer) iblockdata.get(BlockCocoa.AGE) + 1), 2); // CraftBukkit
+     }
+ 
+     @Override

paper-server/nms-patches/net/minecraft/world/level/block/BlockCommand.patch

@@ -0,0 +1,27 @@
+--- a/net/minecraft/server/BlockCommand.java
++++ b/net/minecraft/server/BlockCommand.java
+@@ -4,6 +4,8 @@
+ import org.apache.logging.log4j.LogManager;
+ import org.apache.logging.log4j.Logger;
+ 
++import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
++
+ public class BlockCommand extends BlockTileEntity {
+ 
+     private static final Logger LOGGER = LogManager.getLogger();
+@@ -32,6 +34,15 @@
+                 TileEntityCommand tileentitycommand = (TileEntityCommand) tileentity;
+                 boolean flag1 = world.isBlockIndirectlyPowered(blockposition);
+                 boolean flag2 = tileentitycommand.f();
++                // CraftBukkit start
++                org.bukkit.block.Block bukkitBlock = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
++                int old = flag2 ? 15 : 0;
++                int current = flag1 ? 15 : 0;
++
++                BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(bukkitBlock, old, current);
++                world.getServer().getPluginManager().callEvent(eventRedstone);
++                flag1 = eventRedstone.getNewCurrent() > 0;
++                // CraftBukkit end
+ 
+                 tileentitycommand.a(flag1);
+                 if (!flag2 && !tileentitycommand.g() && tileentitycommand.m() != TileEntityCommand.Type.SEQUENCE) {

paper-server/nms-patches/net/minecraft/world/level/block/BlockComposter.patch

@@ -0,0 +1,138 @@
+--- a/net/minecraft/server/BlockComposter.java
++++ b/net/minecraft/server/BlockComposter.java
+@@ -5,12 +5,17 @@
+ import java.util.Random;
+ import javax.annotation.Nullable;
+ 
++// CraftBukkit start
++import org.bukkit.craftbukkit.inventory.CraftBlockInventoryHolder;
++import org.bukkit.craftbukkit.util.DummyGeneratorAccess;
++// CraftBukkit end
++
+ public class BlockComposter extends Block implements IInventoryHolder {
+ 
+     public static final BlockStateInteger a = BlockProperties.as;
+     public static final Object2FloatMap<IMaterial> b = new Object2FloatOpenHashMap();
+     private static final VoxelShape c = VoxelShapes.b();
+-    private static final VoxelShape[] d = (VoxelShape[]) SystemUtils.a((Object) (new VoxelShape[9]), (avoxelshape) -> {
++    private static final VoxelShape[] d = (VoxelShape[]) SystemUtils.a((new VoxelShape[9]), (avoxelshape) -> { // CraftBukkit - decompile error
+         for (int i = 0; i < 8; ++i) {
+             avoxelshape[i] = VoxelShapes.a(BlockComposter.c, Block.a(2.0D, (double) Math.max(2, 1 + i * 2), 2.0D, 14.0D, 16.0D, 14.0D), OperatorBoolean.ONLY_FIRST);
+         }
+@@ -156,18 +161,25 @@
+ 
+             return EnumInteractionResult.a(world.isClientSide);
+         } else if (i == 8) {
+-            d(iblockdata, world, blockposition);
++            d(iblockdata, world, blockposition, (Entity) null); // CraftBukkit - no event for players
+             return EnumInteractionResult.a(world.isClientSide);
+         } else {
+             return EnumInteractionResult.PASS;
+         }
+     }
+ 
+-    public static IBlockData a(IBlockData iblockdata, WorldServer worldserver, ItemStack itemstack, BlockPosition blockposition) {
++    public static IBlockData a(IBlockData iblockdata, WorldServer worldserver, ItemStack itemstack, BlockPosition blockposition, Entity entity) { // CraftBukkit
+         int i = (Integer) iblockdata.get(BlockComposter.a);
+ 
+         if (i < 7 && BlockComposter.b.containsKey(itemstack.getItem())) {
+-            IBlockData iblockdata1 = b(iblockdata, (GeneratorAccess) worldserver, blockposition, itemstack);
++            // CraftBukkit start
++            double rand = worldserver.getRandom().nextDouble();
++            IBlockData iblockdata1 = b(iblockdata, DummyGeneratorAccess.INSTANCE, blockposition, itemstack, rand);
++            if (iblockdata == iblockdata1 || org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(entity, blockposition, iblockdata1).isCancelled()) {
++                return iblockdata;
++            }
++            iblockdata1 = b(iblockdata, (GeneratorAccess) worldserver, blockposition, itemstack, rand);
++            // CraftBukkit end
+ 
+             itemstack.subtract(1);
+             return iblockdata1;
+@@ -176,7 +188,15 @@
+         }
+     }
+ 
+-    public static IBlockData d(IBlockData iblockdata, World world, BlockPosition blockposition) {
++    // CraftBukkit start
++    public static IBlockData d(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
++        if (entity != null) {
++            IBlockData iblockdata1 = d(iblockdata, DummyGeneratorAccess.INSTANCE, blockposition);
++            if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(entity, blockposition, iblockdata1).isCancelled()) {
++                return iblockdata;
++            }
++        }
++        // CraftBukkit end
+         if (!world.isClientSide) {
+             float f = 0.7F;
+             double d0 = (double) (world.random.nextFloat() * 0.7F) + 0.15000000596046448D;
+@@ -202,10 +222,16 @@
+     }
+ 
+     private static IBlockData b(IBlockData iblockdata, GeneratorAccess generatoraccess, BlockPosition blockposition, ItemStack itemstack) {
++        // CraftBukkit start
++        return b(iblockdata, generatoraccess, blockposition, itemstack, generatoraccess.getRandom().nextDouble());
++    }
++
++    private static IBlockData b(IBlockData iblockdata, GeneratorAccess generatoraccess, BlockPosition blockposition, ItemStack itemstack, double rand) {
++        // CraftBukkit end
+         int i = (Integer) iblockdata.get(BlockComposter.a);
+         float f = BlockComposter.b.getFloat(itemstack.getItem());
+ 
+-        if ((i != 0 || f <= 0.0F) && generatoraccess.getRandom().nextDouble() >= (double) f) {
++        if ((i != 0 || f <= 0.0F) && rand >= (double) f) {
+             return iblockdata;
+         } else {
+             int j = i + 1;
+@@ -253,7 +279,8 @@
+     public IWorldInventory a(IBlockData iblockdata, GeneratorAccess generatoraccess, BlockPosition blockposition) {
+         int i = (Integer) iblockdata.get(BlockComposter.a);
+ 
+-        return (IWorldInventory) (i == 8 ? new BlockComposter.ContainerOutput(iblockdata, generatoraccess, blockposition, new ItemStack(Items.BONE_MEAL)) : (i < 7 ? new BlockComposter.ContainerInput(iblockdata, generatoraccess, blockposition) : new BlockComposter.ContainerEmpty()));
++        // CraftBukkit - empty generatoraccess, blockposition
++        return (IWorldInventory) (i == 8 ? new BlockComposter.ContainerOutput(iblockdata, generatoraccess, blockposition, new ItemStack(Items.BONE_MEAL)) : (i < 7 ? new BlockComposter.ContainerInput(iblockdata, generatoraccess, blockposition) : new BlockComposter.ContainerEmpty(generatoraccess, blockposition)));
+     }
+ 
+     static class ContainerInput extends InventorySubcontainer implements IWorldInventory {
+@@ -265,6 +292,7 @@
+ 
+         public ContainerInput(IBlockData iblockdata, GeneratorAccess generatoraccess, BlockPosition blockposition) {
+             super(1);
++            this.bukkitOwner = new CraftBlockInventoryHolder(generatoraccess, blockposition, this); // CraftBukkit
+             this.a = iblockdata;
+             this.b = generatoraccess;
+             this.c = blockposition;
+@@ -317,6 +345,7 @@
+             this.blockData = iblockdata;
+             this.generatorAccess = generatoraccess;
+             this.blockPosition = blockposition;
++            this.bukkitOwner = new CraftBlockInventoryHolder(generatoraccess, blockposition, this); // CraftBukkit
+         }
+ 
+         @Override
+@@ -341,15 +370,23 @@
+ 
+         @Override
+         public void update() {
+-            BlockComposter.d(this.blockData, this.generatorAccess, this.blockPosition);
+-            this.emptied = true;
++            // CraftBukkit start - allow putting items back (eg cancelled InventoryMoveItemEvent)
++            if (this.isEmpty()) {
++                BlockComposter.d(this.blockData, this.generatorAccess, this.blockPosition);
++                this.emptied = true;
++            } else {
++                this.generatorAccess.setTypeAndData(this.blockPosition, this.blockData, 3);
++                this.emptied = false;
++            }
++            // CraftBukkit end
+         }
+     }
+ 
+     static class ContainerEmpty extends InventorySubcontainer implements IWorldInventory {
+ 
+-        public ContainerEmpty() {
++        public ContainerEmpty(GeneratorAccess generatoraccess, BlockPosition blockposition) { // CraftBukkit
+             super(0);
++            this.bukkitOwner = new CraftBlockInventoryHolder(generatoraccess, blockposition, this); // CraftBukkit
+         }
+ 
+         @Override

paper-server/nms-patches/net/minecraft/world/level/block/BlockConcretePowder.patch

@@ -0,0 +1,74 @@
+--- a/net/minecraft/server/BlockConcretePowder.java
++++ b/net/minecraft/server/BlockConcretePowder.java
+@@ -1,5 +1,10 @@
+ package net.minecraft.server;
+ 
++// CraftBukkit start
++import org.bukkit.craftbukkit.block.CraftBlockState;
++import org.bukkit.event.block.BlockFormEvent;
++// CraftBukkit end
++
+ public class BlockConcretePowder extends BlockFalling {
+ 
+     private final IBlockData a;
+@@ -12,7 +17,7 @@
+     @Override
+     public void a(World world, BlockPosition blockposition, IBlockData iblockdata, IBlockData iblockdata1, EntityFallingBlock entityfallingblock) {
+         if (canHarden(world, blockposition, iblockdata1)) {
+-            world.setTypeAndData(blockposition, this.a, 3);
++            org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(world, blockposition, this.a, 3); // CraftBukkit
+         }
+ 
+     }
+@@ -23,7 +28,24 @@
+         BlockPosition blockposition = blockactioncontext.getClickPosition();
+         IBlockData iblockdata = world.getType(blockposition);
+ 
+-        return canHarden(world, blockposition, iblockdata) ? this.a : super.getPlacedState(blockactioncontext);
++        // CraftBukkit start
++        if (!canHarden(world, blockposition, iblockdata)) {
++            return super.getPlacedState(blockactioncontext);
++        }
++
++        // TODO: An event factory call for methods like this
++        CraftBlockState blockState = CraftBlockState.getBlockState(world, blockposition);
++        blockState.setData(this.a);
++
++        BlockFormEvent event = new BlockFormEvent(blockState.getBlock(), blockState);
++        world.getMinecraftServer().server.getPluginManager().callEvent(event);
++
++        if (!event.isCancelled()) {
++            return blockState.getHandle();
++        }
++
++        return super.getPlacedState(blockactioncontext);
++        // CraftBukkit end
+     }
+ 
+     private static boolean canHarden(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata) {
+@@ -59,6 +81,24 @@
+ 
+     @Override
+     public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+-        return a((IBlockAccess) generatoraccess, blockposition) ? this.a : super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
++        // CraftBukkit start
++        if (a((IBlockAccess) generatoraccess, blockposition)) {
++            // Suppress during worldgen
++            if (!(generatoraccess instanceof World)) {
++                return this.a;
++            }
++            CraftBlockState blockState = CraftBlockState.getBlockState(generatoraccess, blockposition);
++            blockState.setData(this.a);
++
++            BlockFormEvent event = new BlockFormEvent(blockState.getBlock(), blockState);
++            ((World) generatoraccess).getServer().getPluginManager().callEvent(event);
++
++            if (!event.isCancelled()) {
++                return blockState.getHandle();
++            }
++        }
++
++        return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
++        // CraftBukkit end
+     }
+ }

paper-server/nms-patches/net/minecraft/world/level/block/BlockCoral.patch

@@ -0,0 +1,14 @@
+--- a/net/minecraft/server/BlockCoral.java
++++ b/net/minecraft/server/BlockCoral.java
+@@ -15,6 +15,11 @@
+     @Override
+     public void tickAlways(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, Random random) {
+         if (!this.a((IBlockAccess) worldserver, blockposition)) {
++            // CraftBukkit start
++            if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(worldserver, blockposition, this.a.getBlockData()).isCancelled()) {
++                return;
++            }
++            // CraftBukkit end
+             worldserver.setTypeAndData(blockposition, this.a.getBlockData(), 2);
+         }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockCoralFan.patch

@@ -0,0 +1,14 @@
+--- a/net/minecraft/server/BlockCoralFan.java
++++ b/net/minecraft/server/BlockCoralFan.java
+@@ -19,6 +19,11 @@
+     @Override
+     public void tickAlways(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, Random random) {
+         if (!c(iblockdata, (IBlockAccess) worldserver, blockposition)) {
++            // CraftBukkit start
++            if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(worldserver, blockposition, this.a.getBlockData().set(BlockCoralFan.b, false)).isCancelled()) {
++                return;
++            }
++            // CraftBukkit end
+             worldserver.setTypeAndData(blockposition, (IBlockData) this.a.getBlockData().set(BlockCoralFan.b, false), 2);
+         }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockCoralFanWall.patch

@@ -0,0 +1,14 @@
+--- a/net/minecraft/server/BlockCoralFanWall.java
++++ b/net/minecraft/server/BlockCoralFanWall.java
+@@ -19,6 +19,11 @@
+     @Override
+     public void tickAlways(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, Random random) {
+         if (!c(iblockdata, (IBlockAccess) worldserver, blockposition)) {
++            // CraftBukkit start
++            if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(worldserver, blockposition, this.c.getBlockData().set(BlockCoralFanWall.b, false).set(BlockCoralFanWall.a, iblockdata.get(BlockCoralFanWall.a))).isCancelled()) {
++                return;
++            }
++            // CraftBukkit end
+             worldserver.setTypeAndData(blockposition, (IBlockData) ((IBlockData) this.c.getBlockData().set(BlockCoralFanWall.b, false)).set(BlockCoralFanWall.a, iblockdata.get(BlockCoralFanWall.a)), 2);
+         }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockCoralPlant.patch

@@ -0,0 +1,14 @@
+--- a/net/minecraft/server/BlockCoralPlant.java
++++ b/net/minecraft/server/BlockCoralPlant.java
+@@ -20,6 +20,11 @@
+     @Override
+     public void tickAlways(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, Random random) {
+         if (!c(iblockdata, (IBlockAccess) worldserver, blockposition)) {
++            // CraftBukkit start
++            if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(worldserver, blockposition, this.c.getBlockData().set(BlockCoralPlant.b, false)).isCancelled()) {
++                return;
++            }
++            // CraftBukkit end
+             worldserver.setTypeAndData(blockposition, (IBlockData) this.c.getBlockData().set(BlockCoralPlant.b, false), 2);
+         }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockCrops.patch

@@ -0,0 +1,38 @@
+--- a/net/minecraft/server/BlockCrops.java
++++ b/net/minecraft/server/BlockCrops.java
+@@ -2,6 +2,8 @@
+ 
+ import java.util.Random;
+ 
++import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
++
+ public class BlockCrops extends BlockPlant implements IBlockFragilePlantElement {
+ 
+     public static final BlockStateInteger AGE = BlockProperties.ai;
+@@ -56,7 +58,7 @@
+                 float f = a((Block) this, (IBlockAccess) worldserver, blockposition);
+ 
+                 if (random.nextInt((int) (25.0F / f) + 1) == 0) {
+-                    worldserver.setTypeAndData(blockposition, this.setAge(i + 1), 2);
++                    CraftEventFactory.handleBlockGrowEvent(worldserver, blockposition, this.setAge(i + 1), 2); // CraftBukkit
+                 }
+             }
+         }
+@@ -71,7 +73,7 @@
+             i = j;
+         }
+ 
+-        world.setTypeAndData(blockposition, this.setAge(i), 2);
++        CraftEventFactory.handleBlockGrowEvent(world, blockposition, this.setAge(i), 2); // CraftBukkit
+     }
+ 
+     protected int a(World world) {
+@@ -129,7 +131,7 @@
+ 
+     @Override
+     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
+-        if (entity instanceof EntityRavager && world.getGameRules().getBoolean(GameRules.MOB_GRIEFING)) {
++        if (entity instanceof EntityRavager && !CraftEventFactory.callEntityChangeBlockEvent(entity, blockposition, Blocks.AIR.getBlockData(), !world.getGameRules().getBoolean(GameRules.MOB_GRIEFING)).isCancelled()) { // CraftBukkit
+             world.a(blockposition, true, entity);
+         }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockDaylightDetector.patch

@@ -0,0 +1,10 @@
+--- a/net/minecraft/server/BlockDaylightDetector.java
++++ b/net/minecraft/server/BlockDaylightDetector.java
+@@ -43,6 +43,7 @@
+ 
+             i = MathHelper.clamp(i, 0, 15);
+             if ((Integer) iblockdata.get(BlockDaylightDetector.POWER) != i) {
++                i = org.bukkit.craftbukkit.event.CraftEventFactory.callRedstoneChange(world, blockposition, ((Integer) iblockdata.get(POWER)), i).getNewCurrent(); // CraftBukkit - Call BlockRedstoneEvent
+                 world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockDaylightDetector.POWER, i), 3);
+             }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockDiodeAbstract.patch

@@ -0,0 +1,30 @@
+--- a/net/minecraft/server/BlockDiodeAbstract.java
++++ b/net/minecraft/server/BlockDiodeAbstract.java
+@@ -2,6 +2,8 @@
+ 
+ import java.util.Random;
+ 
++import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
++
+ public abstract class BlockDiodeAbstract extends BlockFacingHorizontal {
+ 
+     protected static final VoxelShape b = Block.a(0.0D, 0.0D, 0.0D, 16.0D, 2.0D, 16.0D);
+@@ -28,8 +30,18 @@
+             boolean flag1 = this.a((World) worldserver, blockposition, iblockdata);
+ 
+             if (flag && !flag1) {
++                // CraftBukkit start
++                if (CraftEventFactory.callRedstoneChange(worldserver, blockposition, 15, 0).getNewCurrent() != 0) {
++                    return;
++                }
++                // CraftBukkit end
+                 worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockDiodeAbstract.c, false), 2);
+             } else if (!flag) {
++                // CraftBukkit start
++                if (CraftEventFactory.callRedstoneChange(worldserver, blockposition, 0, 15).getNewCurrent() != 15) {
++                    return;
++                }
++                // CraftBukkit end
+                 worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockDiodeAbstract.c, true), 2);
+                 if (!flag1) {
+                     worldserver.getBlockTickList().a(blockposition, this, this.g(iblockdata), TickListPriority.VERY_HIGH);

paper-server/nms-patches/net/minecraft/world/level/block/BlockDirtSnowSpreadable.patch

@@ -0,0 +1,23 @@
+--- a/net/minecraft/server/BlockDirtSnowSpreadable.java
++++ b/net/minecraft/server/BlockDirtSnowSpreadable.java
+@@ -32,6 +32,11 @@
+     @Override
+     public void tick(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, Random random) {
+         if (!b(iblockdata, (IWorldReader) worldserver, blockposition)) {
++            // CraftBukkit start
++            if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(worldserver, blockposition, Blocks.DIRT.getBlockData()).isCancelled()) {
++                return;
++            }
++            // CraftBukkit end
+             worldserver.setTypeUpdate(blockposition, Blocks.DIRT.getBlockData());
+         } else {
+             if (worldserver.getLightLevel(blockposition.up()) >= 9) {
+@@ -41,7 +46,7 @@
+                     BlockPosition blockposition1 = blockposition.b(random.nextInt(3) - 1, random.nextInt(5) - 3, random.nextInt(3) - 1);
+ 
+                     if (worldserver.getType(blockposition1).a(Blocks.DIRT) && c(iblockdata1, (IWorldReader) worldserver, blockposition1)) {
+-                        worldserver.setTypeUpdate(blockposition1, (IBlockData) iblockdata1.set(BlockDirtSnowSpreadable.a, worldserver.getType(blockposition1.up()).a(Blocks.SNOW)));
++                        org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(worldserver, blockposition, blockposition1, (IBlockData) iblockdata1.set(BlockDirtSnowSpreadable.a, worldserver.getType(blockposition1.up()).a(Blocks.SNOW))); // CraftBukkit
+                     }
+                 }
+             }

paper-server/nms-patches/net/minecraft/world/level/block/BlockDispenser.patch

@@ -0,0 +1,22 @@
+--- a/net/minecraft/server/BlockDispenser.java
++++ b/net/minecraft/server/BlockDispenser.java
+@@ -8,9 +8,10 @@
+ 
+     public static final BlockStateDirection FACING = BlockDirectional.FACING;
+     public static final BlockStateBoolean TRIGGERED = BlockProperties.A;
+-    public static final Map<Item, IDispenseBehavior> REGISTRY = (Map) SystemUtils.a((Object) (new Object2ObjectOpenHashMap()), (object2objectopenhashmap) -> {
++    public static final Map<Item, IDispenseBehavior> REGISTRY = (Map) SystemUtils.a((new Object2ObjectOpenHashMap()), (object2objectopenhashmap) -> { // CraftBukkit - decompile error
+         object2objectopenhashmap.defaultReturnValue(new DispenseBehaviorItem());
+     });
++    public static boolean eventFired = false; // CraftBukkit
+ 
+     public static void a(IMaterial imaterial, IDispenseBehavior idispensebehavior) {
+         BlockDispenser.REGISTRY.put(imaterial.getItem(), idispensebehavior);
+@@ -53,6 +54,7 @@
+             IDispenseBehavior idispensebehavior = this.a(itemstack);
+ 
+             if (idispensebehavior != IDispenseBehavior.NONE) {
++                eventFired = false; // CraftBukkit - reset event status
+                 tileentitydispenser.setItem(i, idispensebehavior.dispense(sourceblock, itemstack));
+             }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockDoor.patch

@@ -0,0 +1,38 @@
+--- a/net/minecraft/server/BlockDoor.java
++++ b/net/minecraft/server/BlockDoor.java
+@@ -2,6 +2,8 @@
+ 
+ import javax.annotation.Nullable;
+ 
++import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
++
+ public class BlockDoor extends Block {
+ 
+     public static final BlockStateDirection FACING = BlockFacingHorizontal.FACING;
+@@ -157,9 +159,24 @@
+ 
+     @Override
+     public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1, boolean flag) {
+-        boolean flag1 = world.isBlockIndirectlyPowered(blockposition) || world.isBlockIndirectlyPowered(blockposition.shift(iblockdata.get(BlockDoor.HALF) == BlockPropertyDoubleBlockHalf.LOWER ? EnumDirection.UP : EnumDirection.DOWN));
++        // CraftBukkit start
++        BlockPosition otherHalf = blockposition.shift(iblockdata.get(BlockDoor.HALF) == BlockPropertyDoubleBlockHalf.LOWER ? EnumDirection.UP : EnumDirection.DOWN);
++
++        org.bukkit.World bworld = world.getWorld();
++        org.bukkit.block.Block bukkitBlock = bworld.getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
++        org.bukkit.block.Block blockTop = bworld.getBlockAt(otherHalf.getX(), otherHalf.getY(), otherHalf.getZ());
++
++        int power = bukkitBlock.getBlockPower();
++        int powerTop = blockTop.getBlockPower();
++        if (powerTop > power) power = powerTop;
++        int oldPower = (Boolean) iblockdata.get(BlockDoor.POWERED) ? 15 : 0;
++
++        if (oldPower == 0 ^ power == 0) {
++            BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(bukkitBlock, oldPower, power);
++            world.getServer().getPluginManager().callEvent(eventRedstone);
+ 
+-        if (block != this && flag1 != (Boolean) iblockdata.get(BlockDoor.POWERED)) {
++            boolean flag1 = eventRedstone.getNewCurrent() > 0;
++            // CraftBukkit end
+             if (flag1 != (Boolean) iblockdata.get(BlockDoor.OPEN)) {
+                 this.a(world, blockposition, flag1);
+             }

paper-server/nms-patches/net/minecraft/world/level/block/BlockDragonEgg.patch

@@ -0,0 +1,29 @@
+--- a/net/minecraft/server/BlockDragonEgg.java
++++ b/net/minecraft/server/BlockDragonEgg.java
+@@ -1,5 +1,7 @@
+ package net.minecraft.server;
+ 
++import org.bukkit.event.block.BlockFromToEvent; // CraftBukkit
++
+ public class BlockDragonEgg extends BlockFalling {
+ 
+     protected static final VoxelShape a = Block.a(1.0D, 0.0D, 1.0D, 15.0D, 16.0D, 15.0D);
+@@ -29,6 +31,18 @@
+             BlockPosition blockposition1 = blockposition.b(world.random.nextInt(16) - world.random.nextInt(16), world.random.nextInt(8) - world.random.nextInt(8), world.random.nextInt(16) - world.random.nextInt(16));
+ 
+             if (world.getType(blockposition1).isAir()) {
++                // CraftBukkit start
++                org.bukkit.block.Block from = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
++                org.bukkit.block.Block to = world.getWorld().getBlockAt(blockposition1.getX(), blockposition1.getY(), blockposition1.getZ());
++                BlockFromToEvent event = new BlockFromToEvent(from, to);
++                org.bukkit.Bukkit.getPluginManager().callEvent(event);
++
++                if (event.isCancelled()) {
++                    return;
++                }
++
++                blockposition1 = new BlockPosition(event.getToBlock().getX(), event.getToBlock().getY(), event.getToBlock().getZ());
++                // CraftBukkit end
+                 if (world.isClientSide) {
+                     for (int j = 0; j < 128; ++j) {
+                         double d0 = world.random.nextDouble();

paper-server/nms-patches/net/minecraft/world/level/block/BlockDropper.patch

@@ -0,0 +1,41 @@
+--- a/net/minecraft/server/BlockDropper.java
++++ b/net/minecraft/server/BlockDropper.java
+@@ -1,5 +1,10 @@
+ package net.minecraft.server;
+ 
++// CraftBukkit start
++import org.bukkit.craftbukkit.inventory.CraftItemStack;
++import org.bukkit.event.inventory.InventoryMoveItemEvent;
++// CraftBukkit end
++
+ public class BlockDropper extends BlockDispenser {
+ 
+     private static final IDispenseBehavior c = new DispenseBehaviorItem();
+@@ -37,8 +42,25 @@
+                 if (iinventory == null) {
+                     itemstack1 = BlockDropper.c.dispense(sourceblock, itemstack);
+                 } else {
+-                    itemstack1 = TileEntityHopper.addItem(tileentitydispenser, iinventory, itemstack.cloneItemStack().cloneAndSubtract(1), enumdirection.opposite());
+-                    if (itemstack1.isEmpty()) {
++                    // CraftBukkit start - Fire event when pushing items into other inventories
++                    CraftItemStack oitemstack = CraftItemStack.asCraftMirror(itemstack.cloneItemStack().cloneAndSubtract(1));
++
++                    org.bukkit.inventory.Inventory destinationInventory;
++                    // Have to special case large chests as they work oddly
++                    if (iinventory instanceof InventoryLargeChest) {
++                        destinationInventory = new org.bukkit.craftbukkit.inventory.CraftInventoryDoubleChest((InventoryLargeChest) iinventory);
++                    } else {
++                        destinationInventory = iinventory.getOwner().getInventory();
++                    }
++
++                    InventoryMoveItemEvent event = new InventoryMoveItemEvent(tileentitydispenser.getOwner().getInventory(), oitemstack.clone(), destinationInventory, true);
++                    worldserver.getServer().getPluginManager().callEvent(event);
++                    if (event.isCancelled()) {
++                        return;
++                    }
++                    itemstack1 = TileEntityHopper.addItem(tileentitydispenser, iinventory, CraftItemStack.asNMSCopy(event.getItem()), enumdirection.opposite());
++                    if (event.getItem().equals(oitemstack) && itemstack1.isEmpty()) {
++                        // CraftBukkit end
+                         itemstack1 = itemstack.cloneItemStack();
+                         itemstack1.subtract(1);
+                     } else {

paper-server/nms-patches/net/minecraft/world/level/block/BlockEnderPortal.patch

@@ -0,0 +1,38 @@
+--- a/net/minecraft/server/BlockEnderPortal.java
++++ b/net/minecraft/server/BlockEnderPortal.java
+@@ -1,5 +1,10 @@
+ package net.minecraft.server;
+ 
++// CraftBukkit start
++import org.bukkit.event.entity.EntityPortalEnterEvent;
++import org.bukkit.event.player.PlayerTeleportEvent;
++// CraftBukkit end
++
+ public class BlockEnderPortal extends BlockTileEntity {
+ 
+     protected static final VoxelShape a = Block.a(0.0D, 0.0D, 0.0D, 16.0D, 12.0D, 16.0D);
+@@ -21,13 +26,22 @@
+     @Override
+     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
+         if (world instanceof WorldServer && !entity.isPassenger() && !entity.isVehicle() && entity.canPortal() && VoxelShapes.c(VoxelShapes.a(entity.getBoundingBox().d((double) (-blockposition.getX()), (double) (-blockposition.getY()), (double) (-blockposition.getZ()))), iblockdata.getShape(world, blockposition), OperatorBoolean.AND)) {
+-            ResourceKey<World> resourcekey = world.getDimensionKey() == World.THE_END ? World.OVERWORLD : World.THE_END;
++            ResourceKey<World> resourcekey = world.getTypeKey() == DimensionManager.THE_END ? World.OVERWORLD : World.THE_END; // CraftBukkit - SPIGOT-6152: send back to main overworld in custom ends
+             WorldServer worldserver = ((WorldServer) world).getMinecraftServer().getWorldServer(resourcekey);
+ 
+             if (worldserver == null) {
+-                return;
++                // return; // CraftBukkit - always fire event in case plugins wish to change it
+             }
+ 
++            // CraftBukkit start - Entity in portal
++            EntityPortalEnterEvent event = new EntityPortalEnterEvent(entity.getBukkitEntity(), new org.bukkit.Location(world.getWorld(), blockposition.getX(), blockposition.getY(), blockposition.getZ()));
++            world.getServer().getPluginManager().callEvent(event);
++
++            if (entity instanceof EntityPlayer) {
++                ((EntityPlayer) entity).b(worldserver, PlayerTeleportEvent.TeleportCause.END_PORTAL);
++                return;
++            }
++            // CraftBukkit end
+             entity.b(worldserver);
+         }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockFenceGate.patch

@@ -0,0 +1,20 @@
+--- a/net/minecraft/server/BlockFenceGate.java
++++ b/net/minecraft/server/BlockFenceGate.java
+@@ -103,6 +103,17 @@
+     public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1, boolean flag) {
+         if (!world.isClientSide) {
+             boolean flag1 = world.isBlockIndirectlyPowered(blockposition);
++            // CraftBukkit start
++            boolean oldPowered = iblockdata.get(BlockFenceGate.POWERED);
++            if (oldPowered != flag1) {
++                int newPower = flag1 ? 15 : 0;
++                int oldPower = oldPowered ? 15 : 0;
++                org.bukkit.block.Block bukkitBlock = org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition);
++                org.bukkit.event.block.BlockRedstoneEvent eventRedstone = new org.bukkit.event.block.BlockRedstoneEvent(bukkitBlock, oldPower, newPower);
++                world.getServer().getPluginManager().callEvent(eventRedstone);
++                flag1 = eventRedstone.getNewCurrent() > 0;
++            }
++            // CraftBukkit end
+ 
+             if ((Boolean) iblockdata.get(BlockFenceGate.POWERED) != flag1) {
+                 world.setTypeAndData(blockposition, (IBlockData) ((IBlockData) iblockdata.set(BlockFenceGate.POWERED, flag1)).set(BlockFenceGate.OPEN, flag1), 2);

paper-server/nms-patches/net/minecraft/world/level/block/BlockFire.patch

@@ -0,0 +1,141 @@
+--- a/net/minecraft/server/BlockFire.java
++++ b/net/minecraft/server/BlockFire.java
+@@ -8,6 +8,13 @@
+ import java.util.function.Function;
+ import java.util.stream.Collectors;
+ 
++// CraftBukkit start
++import org.bukkit.craftbukkit.block.CraftBlockState;
++import org.bukkit.craftbukkit.event.CraftEventFactory;
++import org.bukkit.event.block.BlockBurnEvent;
++import org.bukkit.event.block.BlockFadeEvent;
++// CraftBukkit end
++
+ public class BlockFire extends BlockFireAbstract {
+ 
+     public static final BlockStateInteger AGE = BlockProperties.aj;
+@@ -64,7 +71,24 @@
+ 
+     @Override
+     public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+-        return this.canPlace(iblockdata, generatoraccess, blockposition) ? this.a(generatoraccess, blockposition, (Integer) iblockdata.get(BlockFire.AGE)) : Blocks.AIR.getBlockData();
++        // CraftBukkit start
++        if (!this.canPlace(iblockdata, generatoraccess, blockposition)) {
++            // Suppress during worldgen
++            if (!(generatoraccess instanceof World)) {
++                return Blocks.AIR.getBlockData();
++            }
++            CraftBlockState blockState = CraftBlockState.getBlockState(generatoraccess, blockposition);
++            blockState.setData(Blocks.AIR.getBlockData());
++
++            BlockFadeEvent event = new BlockFadeEvent(blockState.getBlock(), blockState);
++            ((World) generatoraccess).getServer().getPluginManager().callEvent(event);
++
++            if (!event.isCancelled()) {
++                return blockState.getHandle();
++            }
++        }
++        return this.a(generatoraccess, blockposition, (Integer) iblockdata.get(BlockFire.AGE));
++        // CraftBukkit end
+     }
+ 
+     @Override
+@@ -113,7 +137,7 @@
+         worldserver.getBlockTickList().a(blockposition, this, a(worldserver.random));
+         if (worldserver.getGameRules().getBoolean(GameRules.DO_FIRE_TICK)) {
+             if (!iblockdata.canPlace(worldserver, blockposition)) {
+-                worldserver.a(blockposition, false);
++                fireExtinguished(worldserver, blockposition); // CraftBukkit - invalid place location
+             }
+ 
+             IBlockData iblockdata1 = worldserver.getType(blockposition.down());
+@@ -121,7 +145,7 @@
+             int i = (Integer) iblockdata.get(BlockFire.AGE);
+ 
+             if (!flag && worldserver.isRaining() && this.a((World) worldserver, blockposition) && random.nextFloat() < 0.2F + (float) i * 0.03F) {
+-                worldserver.a(blockposition, false);
++                fireExtinguished(worldserver, blockposition); // CraftBukkit - extinguished by rain
+             } else {
+                 int j = Math.min(15, i + random.nextInt(3) / 2);
+ 
+@@ -135,14 +159,14 @@
+                         BlockPosition blockposition1 = blockposition.down();
+ 
+                         if (!worldserver.getType(blockposition1).d(worldserver, blockposition1, EnumDirection.UP) || i > 3) {
+-                            worldserver.a(blockposition, false);
++                            fireExtinguished(worldserver, blockposition); // CraftBukkit
+                         }
+ 
+                         return;
+                     }
+ 
+                     if (i == 15 && random.nextInt(4) == 0 && !this.e(worldserver.getType(blockposition.down()))) {
+-                        worldserver.a(blockposition, false);
++                        fireExtinguished(worldserver, blockposition); // CraftBukkit
+                         return;
+                     }
+                 }
+@@ -150,12 +174,14 @@
+                 boolean flag1 = worldserver.u(blockposition);
+                 int k = flag1 ? -50 : 0;
+ 
+-                this.trySpread(worldserver, blockposition.east(), 300 + k, random, i);
+-                this.trySpread(worldserver, blockposition.west(), 300 + k, random, i);
+-                this.trySpread(worldserver, blockposition.down(), 250 + k, random, i);
+-                this.trySpread(worldserver, blockposition.up(), 250 + k, random, i);
+-                this.trySpread(worldserver, blockposition.north(), 300 + k, random, i);
+-                this.trySpread(worldserver, blockposition.south(), 300 + k, random, i);
++                // CraftBukkit start - add source blockposition to burn calls
++                this.trySpread(worldserver, blockposition.east(), 300 + k, random, i, blockposition);
++                this.trySpread(worldserver, blockposition.west(), 300 + k, random, i, blockposition);
++                this.trySpread(worldserver, blockposition.down(), 250 + k, random, i, blockposition);
++                this.trySpread(worldserver, blockposition.up(), 250 + k, random, i, blockposition);
++                this.trySpread(worldserver, blockposition.north(), 300 + k, random, i, blockposition);
++                this.trySpread(worldserver, blockposition.south(), 300 + k, random, i, blockposition);
++                // CraftBukkit end
+                 BlockPosition.MutableBlockPosition blockposition_mutableblockposition = new BlockPosition.MutableBlockPosition();
+ 
+                 for (int l = -1; l <= 1; ++l) {
+@@ -181,7 +207,15 @@
+                                     if (i2 > 0 && random.nextInt(k1) <= i2 && (!worldserver.isRaining() || !this.a((World) worldserver, (BlockPosition) blockposition_mutableblockposition))) {
+                                         int j2 = Math.min(15, i + random.nextInt(5) / 4);
+ 
+-                                        worldserver.setTypeAndData(blockposition_mutableblockposition, this.a(worldserver, blockposition_mutableblockposition, j2), 3);
++                                        // CraftBukkit start - Call to stop spread of fire
++                                        if (worldserver.getType(blockposition_mutableblockposition).getBlock() != Blocks.FIRE) {
++                                            if (CraftEventFactory.callBlockIgniteEvent(worldserver, blockposition_mutableblockposition, blockposition).isCancelled()) {
++                                                continue;
++                                            }
++
++                                            CraftEventFactory.handleBlockSpreadEvent(worldserver, blockposition, blockposition_mutableblockposition, this.a(worldserver, blockposition_mutableblockposition, j2), 3); // CraftBukkit
++                                        }
++                                        // CraftBukkit end
+                                     }
+                                 }
+                             }
+@@ -205,12 +239,24 @@
+         return iblockdata.b(BlockProperties.C) && (Boolean) iblockdata.get(BlockProperties.C) ? 0 : this.flameChances.getInt(iblockdata.getBlock());
+     }
+ 
+-    private void trySpread(World world, BlockPosition blockposition, int i, Random random, int j) {
++    private void trySpread(World world, BlockPosition blockposition, int i, Random random, int j, BlockPosition sourceposition) { // CraftBukkit add sourceposition
+         int k = this.getBurnChance(world.getType(blockposition));
+ 
+         if (random.nextInt(i) < k) {
+             IBlockData iblockdata = world.getType(blockposition);
+ 
++            // CraftBukkit start
++            org.bukkit.block.Block theBlock = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
++            org.bukkit.block.Block sourceBlock = world.getWorld().getBlockAt(sourceposition.getX(), sourceposition.getY(), sourceposition.getZ());
++
++            BlockBurnEvent event = new BlockBurnEvent(theBlock, sourceBlock);
++            world.getServer().getPluginManager().callEvent(event);
++
++            if (event.isCancelled()) {
++                return;
++            }
++            // CraftBukkit end
++
+             if (random.nextInt(j + 10) < 5 && !world.isRainingAt(blockposition)) {
+                 int l = Math.min(j + random.nextInt(5) / 4, 15);
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockFireAbstract.patch

@@ -0,0 +1,48 @@
+--- a/net/minecraft/server/BlockFireAbstract.java
++++ b/net/minecraft/server/BlockFireAbstract.java
+@@ -36,7 +36,14 @@
+         if (!entity.isFireProof()) {
+             entity.setFireTicks(entity.getFireTicks() + 1);
+             if (entity.getFireTicks() == 0) {
+-                entity.setOnFire(8);
++                // CraftBukkit start
++                org.bukkit.event.entity.EntityCombustEvent event = new org.bukkit.event.entity.EntityCombustByBlockEvent(org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition), entity.getBukkitEntity(), 8);
++                world.getServer().getPluginManager().callEvent(event);
++
++                if (!event.isCancelled()) {
++                    entity.setOnFire(event.getDuration(), false);
++                }
++                // CraftBukkit end
+             }
+ 
+             entity.damageEntity(DamageSource.FIRE, this.b);
+@@ -58,14 +65,14 @@
+             }
+ 
+             if (!iblockdata.canPlace(world, blockposition)) {
+-                world.a(blockposition, false);
++                fireExtinguished(world, blockposition); // CraftBukkit - fuel block broke
+             }
+ 
+         }
+     }
+ 
+     private static boolean a(World world) {
+-        return world.getDimensionKey() == World.OVERWORLD || world.getDimensionKey() == World.THE_NETHER;
++        return world.getTypeKey() == DimensionManager.OVERWORLD || world.getTypeKey() == DimensionManager.THE_NETHER; // CraftBukkit - getTypeKey()
+     }
+ 
+     @Override
+@@ -109,4 +116,12 @@
+             }
+         }
+     }
++
++    // CraftBukkit start
++    protected void fireExtinguished(GeneratorAccess world, BlockPosition position) {
++        if (!org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, position, Blocks.AIR.getBlockData()).isCancelled()) {
++            world.a(position, false);
++        }
++    }
++    // CraftBukkit end
+ }

paper-server/nms-patches/net/minecraft/world/level/block/BlockFluids.patch

@@ -0,0 +1,27 @@
+--- a/net/minecraft/server/BlockFluids.java
++++ b/net/minecraft/server/BlockFluids.java
+@@ -113,14 +113,20 @@
+                     if (world.getFluid(blockposition1).a((Tag) TagsFluid.WATER)) {
+                         Block block = world.getFluid(blockposition).isSource() ? Blocks.OBSIDIAN : Blocks.COBBLESTONE;
+ 
+-                        world.setTypeUpdate(blockposition, block.getBlockData());
+-                        this.fizz(world, blockposition);
++                        // CraftBukkit start
++                        if (org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(world, blockposition, block.getBlockData())) {
++                            this.fizz(world, blockposition);
++                        }
++                        // CraftBukkit end
+                         return false;
+                     }
+ 
+                     if (flag && world.getType(blockposition1).a(Blocks.BLUE_ICE)) {
+-                        world.setTypeUpdate(blockposition, Blocks.BASALT.getBlockData());
+-                        this.fizz(world, blockposition);
++                        // CraftBukkit start
++                        if (org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(world, blockposition, Blocks.BASALT.getBlockData())) {
++                            this.fizz(world, blockposition);
++                        }
++                        // CraftBukkit end
+                         return false;
+                     }
+                 }

paper-server/nms-patches/net/minecraft/world/level/block/BlockFungi.patch

@@ -0,0 +1,16 @@
+--- a/net/minecraft/server/BlockFungi.java
++++ b/net/minecraft/server/BlockFungi.java
+@@ -38,6 +38,13 @@
+ 
+     @Override
+     public void a(WorldServer worldserver, Random random, BlockPosition blockposition, IBlockData iblockdata) {
++        // CraftBukkit start
++        if (this == Blocks.WARPED_FUNGUS) {
++            BlockSapling.treeType = org.bukkit.TreeType.WARPED_FUNGUS;
++        } else if (this == Blocks.CRIMSON_FUNGUS) {
++            BlockSapling.treeType = org.bukkit.TreeType.CRIMSON_FUNGUS;
++        }
++        // CraftBukkit end
+         ((WorldGenFeatureConfigured) this.b.get()).a(worldserver, worldserver.getChunkProvider().getChunkGenerator(), random, blockposition);
+     }
+ }

paper-server/nms-patches/net/minecraft/world/level/block/BlockGrass.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/server/BlockGrass.java
++++ b/net/minecraft/server/BlockGrass.java
+@@ -64,7 +64,7 @@
+                             }
+ 
+                             if (iblockdata3.canPlace(worldserver, blockposition2)) {
+-                                worldserver.setTypeAndData(blockposition2, iblockdata3, 3);
++                                org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockGrowEvent(worldserver, blockposition2, iblockdata3, 3); // CraftBukkit
+                             }
+                         }
+                     }

paper-server/nms-patches/net/minecraft/world/level/block/BlockGrassPath.patch

@@ -0,0 +1,14 @@
+--- a/net/minecraft/server/BlockGrassPath.java
++++ b/net/minecraft/server/BlockGrassPath.java
+@@ -31,6 +31,11 @@
+ 
+     @Override
+     public void tickAlways(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, Random random) {
++        // CraftBukkit start - do not fade if the block is valid here
++        if (iblockdata.canPlace(worldserver, blockposition)) {
++            return;
++        }
++        // CraftBukkit end
+         BlockSoil.fade(iblockdata, worldserver, blockposition);
+     }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockGrowingTop.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/server/BlockGrowingTop.java
++++ b/net/minecraft/server/BlockGrowingTop.java
+@@ -29,7 +29,7 @@
+             BlockPosition blockposition1 = blockposition.shift(this.a);
+ 
+             if (this.h(worldserver.getType(blockposition1))) {
+-                worldserver.setTypeUpdate(blockposition1, (IBlockData) iblockdata.a((IBlockState) BlockGrowingTop.d));
++                org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(worldserver, blockposition, blockposition1, (IBlockData) iblockdata.a((IBlockState) BlockGrowingTop.d)); // CraftBukkit
+             }
+         }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockIce.patch

@@ -0,0 +1,14 @@
+--- a/net/minecraft/server/BlockIce.java
++++ b/net/minecraft/server/BlockIce.java
+@@ -36,6 +36,11 @@
+     }
+ 
+     protected void melt(IBlockData iblockdata, World world, BlockPosition blockposition) {
++        // CraftBukkit start
++        if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, blockposition, world.getDimensionManager().isNether() ? Blocks.AIR.getBlockData() : Blocks.WATER.getBlockData()).isCancelled()) {
++            return;
++        }
++        // CraftBukkit end
+         if (world.getDimensionManager().isNether()) {
+             world.a(blockposition, false);
+         } else {

paper-server/nms-patches/net/minecraft/world/level/block/BlockJukeBox.patch

@@ -0,0 +1,17 @@
+--- a/net/minecraft/server/BlockJukeBox.java
++++ b/net/minecraft/server/BlockJukeBox.java
+@@ -42,7 +42,13 @@
+         TileEntity tileentity = generatoraccess.getTileEntity(blockposition);
+ 
+         if (tileentity instanceof TileEntityJukeBox) {
+-            ((TileEntityJukeBox) tileentity).setRecord(itemstack.cloneItemStack());
++            // CraftBukkit start - There can only be one
++            itemstack = itemstack.cloneItemStack();
++            if (!itemstack.isEmpty()) {
++                itemstack.setCount(1);
++            }
++            ((TileEntityJukeBox) tileentity).setRecord(itemstack);
++            // CraftBukkit end
+             generatoraccess.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockJukeBox.HAS_RECORD, true), 2);
+         }
+     }

paper-server/nms-patches/net/minecraft/world/level/block/BlockLeaves.patch

@@ -0,0 +1,26 @@
+--- a/net/minecraft/server/BlockLeaves.java
++++ b/net/minecraft/server/BlockLeaves.java
+@@ -2,6 +2,8 @@
+ 
+ import java.util.Random;
+ 
++import org.bukkit.event.block.LeavesDecayEvent; // CraftBukkit
++
+ public class BlockLeaves extends Block {
+ 
+     public static final BlockStateInteger DISTANCE = BlockProperties.an;
+@@ -25,6 +27,14 @@
+     @Override
+     public void tick(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, Random random) {
+         if (!(Boolean) iblockdata.get(BlockLeaves.PERSISTENT) && (Integer) iblockdata.get(BlockLeaves.DISTANCE) == 7) {
++            // CraftBukkit start
++            LeavesDecayEvent event = new LeavesDecayEvent(worldserver.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
++            worldserver.getServer().getPluginManager().callEvent(event);
++
++            if (event.isCancelled() || worldserver.getType(blockposition).getBlock() != this) {
++                return;
++            }
++            // CraftBukkit end
+             c(iblockdata, (World) worldserver, blockposition);
+             worldserver.a(blockposition, false);
+         }

paper-server/nms-patches/net/minecraft/world/level/block/BlockLectern.patch

@@ -0,0 +1,17 @@
+--- a/net/minecraft/server/BlockLectern.java
++++ b/net/minecraft/server/BlockLectern.java
+@@ -165,12 +165,13 @@
+     }
+ 
+     private void d(IBlockData iblockdata, World world, BlockPosition blockposition) {
+-        TileEntity tileentity = world.getTileEntity(blockposition);
++        TileEntity tileentity = world.getTileEntity(blockposition, false); // CraftBukkit - don't validate, type may be changed already
+ 
+         if (tileentity instanceof TileEntityLectern) {
+             TileEntityLectern tileentitylectern = (TileEntityLectern) tileentity;
+             EnumDirection enumdirection = (EnumDirection) iblockdata.get(BlockLectern.a);
+             ItemStack itemstack = tileentitylectern.getBook().cloneItemStack();
++            if (itemstack.isEmpty()) return; // CraftBukkit - SPIGOT-5500
+             float f = 0.25F * (float) enumdirection.getAdjacentX();
+             float f1 = 0.25F * (float) enumdirection.getAdjacentZ();
+             EntityItem entityitem = new EntityItem(world, (double) blockposition.getX() + 0.5D + (double) f, (double) (blockposition.getY() + 1), (double) blockposition.getZ() + 0.5D + (double) f1, itemstack);

paper-server/nms-patches/net/minecraft/world/level/block/BlockLever.patch

@@ -0,0 +1,31 @@
+--- a/net/minecraft/server/BlockLever.java
++++ b/net/minecraft/server/BlockLever.java
+@@ -1,5 +1,7 @@
+ package net.minecraft.server;
+ 
++import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
++
+ public class BlockLever extends BlockAttachable {
+ 
+     public static final BlockStateBoolean POWERED = BlockProperties.w;
+@@ -64,6 +66,20 @@
+ 
+             return EnumInteractionResult.SUCCESS;
+         } else {
++            // CraftBukkit start - Interact Lever
++            boolean powered = iblockdata.get(BlockLever.POWERED); // Old powered state
++            org.bukkit.block.Block block = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
++            int old = (powered) ? 15 : 0;
++            int current = (!powered) ? 15 : 0;
++
++            BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(block, old, current);
++            world.getServer().getPluginManager().callEvent(eventRedstone);
++
++            if ((eventRedstone.getNewCurrent() > 0) != (!powered)) {
++                return EnumInteractionResult.SUCCESS;
++            }
++            // CraftBukkit end
++
+             iblockdata1 = this.d(iblockdata, world, blockposition);
+             float f = (Boolean) iblockdata1.get(BlockLever.POWERED) ? 0.6F : 0.5F;
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockMagma.patch

@@ -0,0 +1,12 @@
+--- a/net/minecraft/server/BlockMagma.java
++++ b/net/minecraft/server/BlockMagma.java
+@@ -11,7 +11,9 @@
+     @Override
+     public void stepOn(World world, BlockPosition blockposition, Entity entity) {
+         if (!entity.isFireProof() && entity instanceof EntityLiving && !EnchantmentManager.i((EntityLiving) entity)) {
++            org.bukkit.craftbukkit.event.CraftEventFactory.blockDamage = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()); // CraftBukkit
+             entity.damageEntity(DamageSource.HOT_FLOOR, 1.0F);
++            org.bukkit.craftbukkit.event.CraftEventFactory.blockDamage = null; // CraftBukkit
+         }
+ 
+         super.stepOn(world, blockposition, entity);

paper-server/nms-patches/net/minecraft/world/level/block/BlockMinecartDetector.patch

@@ -0,0 +1,28 @@
+--- a/net/minecraft/server/BlockMinecartDetector.java
++++ b/net/minecraft/server/BlockMinecartDetector.java
+@@ -6,6 +6,8 @@
+ import java.util.function.Predicate;
+ import javax.annotation.Nullable;
+ 
++import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
++
+ public class BlockMinecartDetector extends BlockMinecartTrackAbstract {
+ 
+     public static final BlockStateEnum<BlockPropertyTrackPosition> SHAPE = BlockProperties.ad;
+@@ -58,6 +60,16 @@
+             }
+ 
+             IBlockData iblockdata1;
++            // CraftBukkit start
++            if (flag != flag1) {
++                org.bukkit.block.Block block = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
++
++                BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(block, flag ? 15 : 0, flag1 ? 15 : 0);
++                world.getServer().getPluginManager().callEvent(eventRedstone);
++
++                flag1 = eventRedstone.getNewCurrent() > 0;
++            }
++            // CraftBukkit end
+ 
+             if (flag1 && !flag) {
+                 iblockdata1 = (IBlockData) iblockdata.set(BlockMinecartDetector.POWERED, true);

paper-server/nms-patches/net/minecraft/world/level/block/BlockMobSpawner.patch

@@ -0,0 +1,22 @@
+--- a/net/minecraft/server/BlockMobSpawner.java
++++ b/net/minecraft/server/BlockMobSpawner.java
+@@ -14,9 +14,19 @@
+     @Override
+     public void dropNaturally(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, ItemStack itemstack) {
+         super.dropNaturally(iblockdata, worldserver, blockposition, itemstack);
++        /* CraftBukkit start - Delegate to getExpDrop
+         int i = 15 + worldserver.random.nextInt(15) + worldserver.random.nextInt(15);
+ 
+         this.dropExperience(worldserver, blockposition, i);
++        */
++    }
++
++    @Override
++    public int getExpDrop(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, ItemStack itemstack) {
++        int i = 15 + worldserver.random.nextInt(15) + worldserver.random.nextInt(15);
++
++        return i;
++        // CraftBukkit end
+     }
+ 
+     @Override

paper-server/nms-patches/net/minecraft/world/level/block/BlockMonsterEggs.patch

@@ -0,0 +1,20 @@
+--- a/net/minecraft/server/BlockMonsterEggs.java
++++ b/net/minecraft/server/BlockMonsterEggs.java
+@@ -3,6 +3,8 @@
+ import com.google.common.collect.Maps;
+ import java.util.Map;
+ 
++import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason; // CraftBukkit
++
+ public class BlockMonsterEggs extends Block {
+ 
+     private final Block a;
+@@ -26,7 +28,7 @@
+         EntitySilverfish entitysilverfish = (EntitySilverfish) EntityTypes.SILVERFISH.a((World) worldserver);
+ 
+         entitysilverfish.setPositionRotation((double) blockposition.getX() + 0.5D, (double) blockposition.getY(), (double) blockposition.getZ() + 0.5D, 0.0F, 0.0F);
+-        worldserver.addEntity(entitysilverfish);
++        worldserver.addEntity(entitysilverfish, SpawnReason.SILVERFISH_BLOCK); // CraftBukkit - add SpawnReason
+         entitysilverfish.doSpawnEffect();
+     }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockMushroom.patch

@@ -0,0 +1,38 @@
+--- a/net/minecraft/server/BlockMushroom.java
++++ b/net/minecraft/server/BlockMushroom.java
+@@ -3,6 +3,10 @@
+ import java.util.Iterator;
+ import java.util.Random;
+ 
++// CraftBukkit start
++import org.bukkit.TreeType;
++// CraftBukkit end
++
+ public class BlockMushroom extends BlockPlant implements IBlockFragilePlantElement {
+ 
+     protected static final VoxelShape a = Block.a(5.0D, 0.0D, 5.0D, 11.0D, 6.0D, 11.0D);
+@@ -45,7 +49,7 @@
+             }
+ 
+             if (worldserver.isEmpty(blockposition2) && iblockdata.canPlace(worldserver, blockposition2)) {
+-                worldserver.setTypeAndData(blockposition2, iblockdata, 2);
++                org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(worldserver, blockposition, blockposition2, iblockdata, 2); // CraftBukkit
+             }
+         }
+ 
+@@ -69,6 +73,7 @@
+         WorldGenFeatureConfigured worldgenfeatureconfigured;
+ 
+         if (this == Blocks.BROWN_MUSHROOM) {
++            BlockSapling.treeType = TreeType.BROWN_MUSHROOM; // CraftBukkit
+             worldgenfeatureconfigured = BiomeDecoratorGroups.HUGE_BROWN_MUSHROOM;
+         } else {
+             if (this != Blocks.RED_MUSHROOM) {
+@@ -76,6 +81,7 @@
+                 return false;
+             }
+ 
++            BlockSapling.treeType = TreeType.RED_MUSHROOM; // CraftBukkit
+             worldgenfeatureconfigured = BiomeDecoratorGroups.HUGE_RED_MUSHROOM;
+         }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockNetherWart.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/server/BlockNetherWart.java
++++ b/net/minecraft/server/BlockNetherWart.java
+@@ -33,7 +33,7 @@
+ 
+         if (i < 3 && random.nextInt(10) == 0) {
+             iblockdata = (IBlockData) iblockdata.set(BlockNetherWart.AGE, i + 1);
+-            worldserver.setTypeAndData(blockposition, iblockdata, 2);
++            org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockGrowEvent(worldserver, blockposition, iblockdata, 2); // CraftBukkit
+         }
+ 
+     }

paper-server/nms-patches/net/minecraft/world/level/block/BlockNote.patch

@@ -0,0 +1,47 @@
+--- a/net/minecraft/server/BlockNote.java
++++ b/net/minecraft/server/BlockNote.java
+@@ -27,7 +27,8 @@
+ 
+         if (flag1 != (Boolean) iblockdata.get(BlockNote.POWERED)) {
+             if (flag1) {
+-                this.play(world, blockposition);
++                this.play(world, blockposition, iblockdata); // CraftBukkit
++                iblockdata = world.getType(blockposition); // CraftBukkit - SPIGOT-5617: update in case changed in event
+             }
+ 
+             world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockNote.POWERED, flag1), 3);
+@@ -35,9 +36,14 @@
+ 
+     }
+ 
+-    private void play(World world, BlockPosition blockposition) {
++    private void play(World world, BlockPosition blockposition, IBlockData data) { // CraftBukkit
+         if (world.getType(blockposition.up()).isAir()) {
+-            world.playBlockAction(blockposition, this, 0, 0);
++            // CraftBukkit start
++            org.bukkit.event.block.NotePlayEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callNotePlayEvent(world, blockposition, data.get(BlockNote.INSTRUMENT), data.get(BlockNote.NOTE));
++            if (!event.isCancelled()) {
++                world.playBlockAction(blockposition, this, 0, 0);
++            }
++            // CraftBukkit end
+         }
+ 
+     }
+@@ -49,7 +55,7 @@
+         } else {
+             iblockdata = (IBlockData) iblockdata.a((IBlockState) BlockNote.NOTE);
+             world.setTypeAndData(blockposition, iblockdata, 3);
+-            this.play(world, blockposition);
++            this.play(world, blockposition, iblockdata); // CraftBukkit
+             entityhuman.a(StatisticList.TUNE_NOTEBLOCK);
+             return EnumInteractionResult.CONSUME;
+         }
+@@ -58,7 +64,7 @@
+     @Override
+     public void attack(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman) {
+         if (!world.isClientSide) {
+-            this.play(world, blockposition);
++            this.play(world, blockposition, iblockdata); // CraftBukkit
+             entityhuman.a(StatisticList.PLAY_NOTEBLOCK);
+         }
+     }

paper-server/nms-patches/net/minecraft/world/level/block/BlockObserver.patch

@@ -0,0 +1,30 @@
+--- a/net/minecraft/server/BlockObserver.java
++++ b/net/minecraft/server/BlockObserver.java
+@@ -2,6 +2,8 @@
+ 
+ import java.util.Random;
+ 
++import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
++
+ public class BlockObserver extends BlockDirectional {
+ 
+     public static final BlockStateBoolean b = BlockProperties.w;
+@@ -29,8 +31,18 @@
+     @Override
+     public void tickAlways(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, Random random) {
+         if ((Boolean) iblockdata.get(BlockObserver.b)) {
++            // CraftBukkit start
++            if (CraftEventFactory.callRedstoneChange(worldserver, blockposition, 15, 0).getNewCurrent() != 0) {
++                return;
++            }
++            // CraftBukkit end
+             worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockObserver.b, false), 2);
+         } else {
++            // CraftBukkit start
++            if (CraftEventFactory.callRedstoneChange(worldserver, blockposition, 0, 15).getNewCurrent() != 15) {
++                return;
++            }
++            // CraftBukkit end
+             worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockObserver.b, true), 2);
+             worldserver.getBlockTickList().a(blockposition, this, 2);
+         }

paper-server/nms-patches/net/minecraft/world/level/block/BlockOre.patch

@@ -0,0 +1,32 @@
+--- a/net/minecraft/server/BlockOre.java
++++ b/net/minecraft/server/BlockOre.java
+@@ -15,6 +15,7 @@
+     @Override
+     public void dropNaturally(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, ItemStack itemstack) {
+         super.dropNaturally(iblockdata, worldserver, blockposition, itemstack);
++        /* CraftBukkit start - Delegated to getExpDrop
+         if (EnchantmentManager.getEnchantmentLevel(Enchantments.SILK_TOUCH, itemstack) == 0) {
+             int i = this.a(worldserver.random);
+ 
+@@ -22,6 +23,21 @@
+                 this.dropExperience(worldserver, blockposition, i);
+             }
+         }
++        // */
+ 
+     }
++
++    @Override
++    public int getExpDrop(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, ItemStack itemstack) {
++        if (EnchantmentManager.getEnchantmentLevel(Enchantments.SILK_TOUCH, itemstack) == 0) {
++            int i = this.a(worldserver.random);
++
++            if (i > 0) {
++                return i;
++            }
++        }
++
++        return 0;
++        // CraftBukkit end
++    }
+ }

paper-server/nms-patches/net/minecraft/world/level/block/BlockPlant.patch

@@ -0,0 +1,18 @@
+--- a/net/minecraft/server/BlockPlant.java
++++ b/net/minecraft/server/BlockPlant.java
+@@ -12,7 +12,14 @@
+ 
+     @Override
+     public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) {
+-        return !iblockdata.canPlace(generatoraccess, blockposition) ? Blocks.AIR.getBlockData() : super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
++        // CraftBukkit start
++        if (!iblockdata.canPlace(generatoraccess, blockposition)) {
++            if (!org.bukkit.craftbukkit.event.CraftEventFactory.callBlockPhysicsEvent(generatoraccess, blockposition).isCancelled()) {
++                return Blocks.AIR.getBlockData();
++            }
++        }
++        return super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1);
++        // CraftBukkit end
+     }
+ 
+     @Override

paper-server/nms-patches/net/minecraft/world/level/block/BlockPortal.patch

@@ -0,0 +1,34 @@
+--- a/net/minecraft/server/BlockPortal.java
++++ b/net/minecraft/server/BlockPortal.java
+@@ -2,6 +2,10 @@
+ 
+ import java.util.Random;
+ 
++// CraftBukkit start
++import org.bukkit.event.entity.EntityPortalEnterEvent;
++// CraftBukkit end
++
+ public class BlockPortal extends Block {
+ 
+     public static final BlockStateEnum<EnumDirection.EnumAxis> AXIS = BlockProperties.E;
+@@ -32,7 +36,8 @@
+             }
+ 
+             if (worldserver.getType(blockposition).a((IBlockAccess) worldserver, blockposition, EntityTypes.ZOMBIFIED_PIGLIN)) {
+-                Entity entity = EntityTypes.ZOMBIFIED_PIGLIN.spawnCreature(worldserver, (NBTTagCompound) null, (IChatBaseComponent) null, (EntityHuman) null, blockposition.up(), EnumMobSpawn.STRUCTURE, false, false);
++                // CraftBukkit - set spawn reason to NETHER_PORTAL
++                Entity entity = EntityTypes.ZOMBIFIED_PIGLIN.spawnCreature(worldserver, (NBTTagCompound) null, (IChatBaseComponent) null, (EntityHuman) null, blockposition.up(), EnumMobSpawn.STRUCTURE, false, false, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NETHER_PORTAL);
+ 
+                 if (entity != null) {
+                     entity.resetPortalCooldown();
+@@ -54,6 +59,10 @@
+     @Override
+     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
+         if (!entity.isPassenger() && !entity.isVehicle() && entity.canPortal()) {
++            // CraftBukkit start - Entity in portal
++            EntityPortalEnterEvent event = new EntityPortalEnterEvent(entity.getBukkitEntity(), new org.bukkit.Location(world.getWorld(), blockposition.getX(), blockposition.getY(), blockposition.getZ()));
++            world.getServer().getPluginManager().callEvent(event);
++            // CraftBukkit end
+             entity.d(blockposition);
+         }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockPoweredRail.patch

@@ -0,0 +1,24 @@
+--- a/net/minecraft/server/BlockPoweredRail.java
++++ b/net/minecraft/server/BlockPoweredRail.java
+@@ -1,5 +1,7 @@
+ package net.minecraft.server;
+ 
++import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
++
+ public class BlockPoweredRail extends BlockMinecartTrackAbstract {
+ 
+     public static final BlockStateEnum<BlockPropertyTrackPosition> SHAPE = BlockProperties.ad;
+@@ -102,6 +104,13 @@
+         boolean flag1 = world.isBlockIndirectlyPowered(blockposition) || this.a(world, blockposition, iblockdata, true, 0) || this.a(world, blockposition, iblockdata, false, 0);
+ 
+         if (flag1 != flag) {
++            // CraftBukkit start
++            int power = flag ? 15 : 0;
++            int newPower = CraftEventFactory.callRedstoneChange(world, blockposition, power, 15 - power).getNewCurrent();
++            if (newPower == power) {
++                return;
++            }
++            // CraftBukkit end
+             world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockPoweredRail.POWERED, flag1), 3);
+             world.applyPhysics(blockposition.down(), this);
+             if (((BlockPropertyTrackPosition) iblockdata.get(BlockPoweredRail.SHAPE)).c()) {

paper-server/nms-patches/net/minecraft/world/level/block/BlockPressurePlateAbstract.patch

@@ -0,0 +1,31 @@
+--- a/net/minecraft/server/BlockPressurePlateAbstract.java
++++ b/net/minecraft/server/BlockPressurePlateAbstract.java
+@@ -2,6 +2,8 @@
+ 
+ import java.util.Random;
+ 
++import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
++
+ public abstract class BlockPressurePlateAbstract extends Block {
+ 
+     protected static final VoxelShape a = Block.a(1.0D, 0.0D, 1.0D, 15.0D, 0.5D, 15.0D);
+@@ -65,6 +67,19 @@
+         boolean flag = i > 0;
+         boolean flag1 = j > 0;
+ 
++        // CraftBukkit start - Interact Pressure Plate
++        org.bukkit.World bworld = world.getWorld();
++        org.bukkit.plugin.PluginManager manager = world.getServer().getPluginManager();
++
++        if (flag != flag1) {
++            BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(bworld.getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()), i, j);
++            manager.callEvent(eventRedstone);
++
++            flag1 = eventRedstone.getNewCurrent() > 0;
++            j = eventRedstone.getNewCurrent();
++        }
++        // CraftBukkit end
++
+         if (i != j) {
+             IBlockData iblockdata1 = this.a(iblockdata, j);
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockPressurePlateBinary.patch

@@ -0,0 +1,38 @@
+--- a/net/minecraft/server/BlockPressurePlateBinary.java
++++ b/net/minecraft/server/BlockPressurePlateBinary.java
+@@ -3,6 +3,8 @@
+ import java.util.Iterator;
+ import java.util.List;
+ 
++import org.bukkit.event.entity.EntityInteractEvent; // CraftBukkit
++
+ public class BlockPressurePlateBinary extends BlockPressurePlateAbstract {
+ 
+     public static final BlockStateBoolean POWERED = BlockProperties.w;
+@@ -66,6 +68,26 @@
+             while (iterator.hasNext()) {
+                 Entity entity = (Entity) iterator.next();
+ 
++                // CraftBukkit start - Call interact event when turning on a pressure plate
++                if (this.getPower(world.getType(blockposition)) == 0) {
++                    org.bukkit.World bworld = world.getWorld();
++                    org.bukkit.plugin.PluginManager manager = world.getServer().getPluginManager();
++                    org.bukkit.event.Cancellable cancellable;
++
++                    if (entity instanceof EntityHuman) {
++                        cancellable = org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerInteractEvent((EntityHuman) entity, org.bukkit.event.block.Action.PHYSICAL, blockposition, null, null, null);
++                    } else {
++                        cancellable = new EntityInteractEvent(entity.getBukkitEntity(), bworld.getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
++                        manager.callEvent((EntityInteractEvent) cancellable);
++                    }
++
++                    // We only want to block turning the plate on if all events are cancelled
++                    if (cancellable.isCancelled()) {
++                        continue;
++                    }
++                }
++                // CraftBukkit end
++
+                 if (!entity.isIgnoreBlockTrigger()) {
+                     return 15;
+                 }

paper-server/nms-patches/net/minecraft/world/level/block/BlockPressurePlateWeighted.patch

@@ -0,0 +1,43 @@
+--- a/net/minecraft/server/BlockPressurePlateWeighted.java
++++ b/net/minecraft/server/BlockPressurePlateWeighted.java
+@@ -1,5 +1,7 @@
+ package net.minecraft.server;
+ 
++import org.bukkit.event.entity.EntityInteractEvent; // CraftBukkit
++
+ public class BlockPressurePlateWeighted extends BlockPressurePlateAbstract {
+ 
+     public static final BlockStateInteger POWER = BlockProperties.az;
+@@ -13,7 +15,31 @@
+ 
+     @Override
+     protected int b(World world, BlockPosition blockposition) {
+-        int i = Math.min(world.a(Entity.class, BlockPressurePlateWeighted.c.a(blockposition)).size(), this.weight);
++        // CraftBukkit start
++        // int i = Math.min(world.a(Entity.class, BlockPressurePlateWeighted.c.a(blockposition)).size(), this.weight);
++        int i = 0;
++        java.util.Iterator iterator = world.a(Entity.class, BlockPressurePlateWeighted.c.a(blockposition)).iterator();
++
++        while (iterator.hasNext()) {
++            Entity entity = (Entity) iterator.next();
++
++            org.bukkit.event.Cancellable cancellable;
++
++            if (entity instanceof EntityHuman) {
++                cancellable = org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerInteractEvent((EntityHuman) entity, org.bukkit.event.block.Action.PHYSICAL, blockposition, null, null, null);
++            } else {
++                cancellable = new EntityInteractEvent(entity.getBukkitEntity(), world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
++                world.getServer().getPluginManager().callEvent((EntityInteractEvent) cancellable);
++            }
++
++            // We only want to block turning the plate on if all events are cancelled
++            if (!cancellable.isCancelled()) {
++                i++;
++            }
++        }
++
++        i = Math.min(i, this.weight);
++        // CraftBukkit end
+ 
+         if (i > 0) {
+             float f = (float) Math.min(this.weight, i) / (float) this.weight;

paper-server/nms-patches/net/minecraft/world/level/block/BlockPumpkinCarved.patch

@@ -0,0 +1,74 @@
+--- a/net/minecraft/server/BlockPumpkinCarved.java
++++ b/net/minecraft/server/BlockPumpkinCarved.java
+@@ -4,6 +4,11 @@
+ import java.util.function.Predicate;
+ import javax.annotation.Nullable;
+ 
++// CraftBukkit start
++import org.bukkit.craftbukkit.util.BlockStateListPopulator;
++import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason;
++// CraftBukkit end
++
+ public class BlockPumpkinCarved extends BlockFacingHorizontal implements ItemWearable {
+ 
+     public static final BlockStateDirection a = BlockFacingHorizontal.FACING;
+@@ -42,19 +47,28 @@
+         EntityPlayer entityplayer;
+         int j;
+ 
++        BlockStateListPopulator blockList = new BlockStateListPopulator(world); // CraftBukkit - Use BlockStateListPopulator
+         if (shapedetector_shapedetectorcollection != null) {
+             for (i = 0; i < this.getSnowmanShape().b(); ++i) {
+                 ShapeDetectorBlock shapedetectorblock = shapedetector_shapedetectorcollection.a(0, i, 0);
+ 
+-                world.setTypeAndData(shapedetectorblock.getPosition(), Blocks.AIR.getBlockData(), 2);
+-                world.triggerEffect(2001, shapedetectorblock.getPosition(), Block.getCombinedId(shapedetectorblock.a()));
++                blockList.setTypeAndData(shapedetectorblock.getPosition(), Blocks.AIR.getBlockData(), 2); // CraftBukkit
++                // world.triggerEffect(2001, shapedetectorblock.getPosition(), Block.getCombinedId(shapedetectorblock.a())); // CraftBukkit
+             }
+ 
+             EntitySnowman entitysnowman = (EntitySnowman) EntityTypes.SNOW_GOLEM.a(world);
+             BlockPosition blockposition1 = shapedetector_shapedetectorcollection.a(0, 2, 0).getPosition();
+ 
+             entitysnowman.setPositionRotation((double) blockposition1.getX() + 0.5D, (double) blockposition1.getY() + 0.05D, (double) blockposition1.getZ() + 0.5D, 0.0F, 0.0F);
+-            world.addEntity(entitysnowman);
++            // CraftBukkit start
++            if (!world.addEntity(entitysnowman, SpawnReason.BUILD_SNOWMAN)) {
++                return;
++            }
++            for (BlockPosition pos : blockList.getBlocks()) {
++                world.triggerEffect(2001, pos, Block.getCombinedId(world.getType(pos)));
++            }
++            blockList.updateList();
++            // CraftBukkit end
+             iterator = world.a(EntityPlayer.class, entitysnowman.getBoundingBox().g(5.0D)).iterator();
+ 
+             while (iterator.hasNext()) {
+@@ -74,8 +88,8 @@
+                     for (int k = 0; k < this.getIronGolemShape().b(); ++k) {
+                         ShapeDetectorBlock shapedetectorblock2 = shapedetector_shapedetectorcollection.a(i, k, 0);
+ 
+-                        world.setTypeAndData(shapedetectorblock2.getPosition(), Blocks.AIR.getBlockData(), 2);
+-                        world.triggerEffect(2001, shapedetectorblock2.getPosition(), Block.getCombinedId(shapedetectorblock2.a()));
++                        blockList.setTypeAndData(shapedetectorblock2.getPosition(), Blocks.AIR.getBlockData(), 2); // CraftBukkit
++                        // world.triggerEffect(2001, shapedetectorblock2.getPosition(), Block.getCombinedId(shapedetectorblock2.a())); // CraftBukkit
+                     }
+                 }
+ 
+@@ -84,7 +98,15 @@
+ 
+                 entityirongolem.setPlayerCreated(true);
+                 entityirongolem.setPositionRotation((double) blockposition2.getX() + 0.5D, (double) blockposition2.getY() + 0.05D, (double) blockposition2.getZ() + 0.5D, 0.0F, 0.0F);
+-                world.addEntity(entityirongolem);
++                // CraftBukkit start
++                if (!world.addEntity(entityirongolem, SpawnReason.BUILD_IRONGOLEM)) {
++                    return;
++                }
++                for (BlockPosition pos : blockList.getBlocks()) {
++                    world.triggerEffect(2001, pos, Block.getCombinedId(world.getType(pos)));
++                }
++                blockList.updateList();
++                // CraftBukkit end
+                 iterator = world.a(EntityPlayer.class, entityirongolem.getBoundingBox().g(5.0D)).iterator();
+ 
+                 while (iterator.hasNext()) {

paper-server/nms-patches/net/minecraft/world/level/block/BlockRedstoneComparator.patch

@@ -0,0 +1,40 @@
+--- a/net/minecraft/server/BlockRedstoneComparator.java
++++ b/net/minecraft/server/BlockRedstoneComparator.java
+@@ -4,6 +4,8 @@
+ import java.util.Random;
+ import javax.annotation.Nullable;
+ 
++import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
++
+ public class BlockRedstoneComparator extends BlockDiodeAbstract implements ITileEntity {
+ 
+     public static final BlockStateEnum<BlockPropertyComparatorMode> MODE = BlockProperties.aG;
+@@ -67,7 +69,8 @@
+ 
+     @Nullable
+     private EntityItemFrame a(World world, EnumDirection enumdirection, BlockPosition blockposition) {
+-        List<EntityItemFrame> list = world.a(EntityItemFrame.class, new AxisAlignedBB((double) blockposition.getX(), (double) blockposition.getY(), (double) blockposition.getZ(), (double) (blockposition.getX() + 1), (double) (blockposition.getY() + 1), (double) (blockposition.getZ() + 1)), (entityitemframe) -> {
++        // CraftBukkit - decompile error
++        List<EntityItemFrame> list = world.a(EntityItemFrame.class, new AxisAlignedBB((double) blockposition.getX(), (double) blockposition.getY(), (double) blockposition.getZ(), (double) (blockposition.getX() + 1), (double) (blockposition.getY() + 1), (double) (blockposition.getZ() + 1)), (java.util.function.Predicate<EntityItemFrame>) (entityitemframe) -> {
+             return entityitemframe != null && entityitemframe.getDirection() == enumdirection;
+         });
+ 
+@@ -122,8 +125,18 @@
+             boolean flag1 = (Boolean) iblockdata.get(BlockRedstoneComparator.c);
+ 
+             if (flag1 && !flag) {
++                // CraftBukkit start
++                if (CraftEventFactory.callRedstoneChange(world, blockposition, 15, 0).getNewCurrent() != 0) {
++                    return;
++                }
++                // CraftBukkit end
+                 world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockRedstoneComparator.c, false), 2);
+             } else if (!flag1 && flag) {
++                // CraftBukkit start
++                if (CraftEventFactory.callRedstoneChange(world, blockposition, 0, 15).getNewCurrent() != 15) {
++                    return;
++                }
++                // CraftBukkit end
+                 world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockRedstoneComparator.c, true), 2);
+             }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockRedstoneLamp.patch

@@ -0,0 +1,35 @@
+--- a/net/minecraft/server/BlockRedstoneLamp.java
++++ b/net/minecraft/server/BlockRedstoneLamp.java
+@@ -3,6 +3,8 @@
+ import java.util.Random;
+ import javax.annotation.Nullable;
+ 
++import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
++
+ public class BlockRedstoneLamp extends Block {
+ 
+     public static final BlockStateBoolean a = BlockRedstoneTorch.LIT;
+@@ -27,6 +29,11 @@
+                 if (flag1) {
+                     world.getBlockTickList().a(blockposition, this, 4);
+                 } else {
++                    // CraftBukkit start
++                    if (CraftEventFactory.callRedstoneChange(world, blockposition, 0, 15).getNewCurrent() != 15) {
++                        return;
++                    }
++                    // CraftBukkit end
+                     world.setTypeAndData(blockposition, (IBlockData) iblockdata.a((IBlockState) BlockRedstoneLamp.a), 2);
+                 }
+             }
+@@ -37,6 +44,11 @@
+     @Override
+     public void tickAlways(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, Random random) {
+         if ((Boolean) iblockdata.get(BlockRedstoneLamp.a) && !worldserver.isBlockIndirectlyPowered(blockposition)) {
++            // CraftBukkit start
++            if (CraftEventFactory.callRedstoneChange(worldserver, blockposition, 15, 0).getNewCurrent() != 0) {
++                return;
++            }
++            // CraftBukkit end
+             worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.a((IBlockState) BlockRedstoneLamp.a), 2);
+         }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockRedstoneOre.patch

@@ -0,0 +1,111 @@
+--- a/net/minecraft/server/BlockRedstoneOre.java
++++ b/net/minecraft/server/BlockRedstoneOre.java
+@@ -2,6 +2,11 @@
+ 
+ import java.util.Random;
+ 
++// CraftBukkit start
++import org.bukkit.craftbukkit.event.CraftEventFactory;
++import org.bukkit.event.entity.EntityInteractEvent;
++// CraftBukkit end
++
+ public class BlockRedstoneOre extends Block {
+ 
+     public static final BlockStateBoolean a = BlockRedstoneTorch.LIT;
+@@ -13,14 +18,30 @@
+ 
+     @Override
+     public void attack(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman) {
+-        interact(iblockdata, world, blockposition);
++        interact(iblockdata, world, blockposition, entityhuman); // CraftBukkit - add entityhuman
+         super.attack(iblockdata, world, blockposition, entityhuman);
+     }
+ 
+     @Override
+     public void stepOn(World world, BlockPosition blockposition, Entity entity) {
+-        interact(world.getType(blockposition), world, blockposition);
+-        super.stepOn(world, blockposition, entity);
++        // CraftBukkit start
++        // interact(world.getType(blockposition), world, blockposition);
++        // super.stepOn(world, blockposition, entity);
++        if (entity instanceof EntityHuman) {
++            org.bukkit.event.player.PlayerInteractEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerInteractEvent((EntityHuman) entity, org.bukkit.event.block.Action.PHYSICAL, blockposition, null, null, null);
++            if (!event.isCancelled()) {
++                interact(world.getType(blockposition), world, blockposition, entity); // add entity
++                super.stepOn(world, blockposition, entity);
++            }
++        } else {
++            EntityInteractEvent event = new EntityInteractEvent(entity.getBukkitEntity(), world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
++            world.getServer().getPluginManager().callEvent(event);
++            if (!event.isCancelled()) {
++                interact(world.getType(blockposition), world, blockposition, entity); // add entity
++                super.stepOn(world, blockposition, entity);
++            }
++        }
++        // CraftBukkit end
+     }
+ 
+     @Override
+@@ -28,7 +49,7 @@
+         if (world.isClientSide) {
+             playEffect(world, blockposition);
+         } else {
+-            interact(iblockdata, world, blockposition);
++            interact(iblockdata, world, blockposition, entityhuman); // CraftBukkit - add entityhuman
+         }
+ 
+         ItemStack itemstack = entityhuman.b(enumhand);
+@@ -36,9 +57,14 @@
+         return itemstack.getItem() instanceof ItemBlock && (new BlockActionContext(entityhuman, enumhand, itemstack, movingobjectpositionblock)).b() ? EnumInteractionResult.PASS : EnumInteractionResult.SUCCESS;
+     }
+ 
+-    private static void interact(IBlockData iblockdata, World world, BlockPosition blockposition) {
++    private static void interact(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) { // CraftBukkit - add Entity
+         playEffect(world, blockposition);
+         if (!(Boolean) iblockdata.get(BlockRedstoneOre.a)) {
++            // CraftBukkit start
++            if (CraftEventFactory.callEntityChangeBlockEvent(entity, blockposition, iblockdata.set(BlockRedstoneOre.a, true)).isCancelled()) {
++                return;
++            }
++            // CraftBukkit end
+             world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockRedstoneOre.a, true), 3);
+         }
+ 
+@@ -52,6 +78,11 @@
+     @Override
+     public void tick(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, Random random) {
+         if ((Boolean) iblockdata.get(BlockRedstoneOre.a)) {
++            // CraftBukkit start
++            if (CraftEventFactory.callBlockFadeEvent(worldserver, blockposition, iblockdata.set(BlockRedstoneOre.a, false)).isCancelled()) {
++                return;
++            }
++            // CraftBukkit end
+             worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockRedstoneOre.a, false), 3);
+         }
+ 
+@@ -60,12 +91,25 @@
+     @Override
+     public void dropNaturally(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, ItemStack itemstack) {
+         super.dropNaturally(iblockdata, worldserver, blockposition, itemstack);
++        /* CraftBukkit start - Delegated to getExpDrop
+         if (EnchantmentManager.getEnchantmentLevel(Enchantments.SILK_TOUCH, itemstack) == 0) {
+             int i = 1 + worldserver.random.nextInt(5);
+ 
+             this.dropExperience(worldserver, blockposition, i);
+         }
++        // */
++
++    }
+ 
++    @Override
++    public int getExpDrop(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, ItemStack itemstack) {
++        if (EnchantmentManager.getEnchantmentLevel(Enchantments.SILK_TOUCH, itemstack) == 0) {
++            int i = 1 + worldserver.random.nextInt(5);
++
++            return i;
++        }
++        return 0;
++        // CraftBukkit end
+     }
+ 
+     private static void playEffect(World world, BlockPosition blockposition) {

paper-server/nms-patches/net/minecraft/world/level/block/BlockRedstoneTorch.patch

@@ -0,0 +1,52 @@
+--- a/net/minecraft/server/BlockRedstoneTorch.java
++++ b/net/minecraft/server/BlockRedstoneTorch.java
+@@ -6,6 +6,8 @@
+ import java.util.Random;
+ import java.util.WeakHashMap;
+ 
++import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
++
+ public class BlockRedstoneTorch extends BlockTorch {
+ 
+     public static final BlockStateBoolean LIT = BlockProperties.r;
+@@ -62,8 +64,24 @@
+             list.remove(0);
+         }
+ 
++        // CraftBukkit start
++        org.bukkit.plugin.PluginManager manager = worldserver.getServer().getPluginManager();
++        org.bukkit.block.Block block = worldserver.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
++        int oldCurrent = ((Boolean) iblockdata.get(BlockRedstoneTorch.LIT)).booleanValue() ? 15 : 0;
++
++        BlockRedstoneEvent event = new BlockRedstoneEvent(block, oldCurrent, oldCurrent);
++        // CraftBukkit end
+         if ((Boolean) iblockdata.get(BlockRedstoneTorch.LIT)) {
+             if (flag) {
++                // CraftBukkit start
++                if (oldCurrent != 0) {
++                    event.setNewCurrent(0);
++                    manager.callEvent(event);
++                    if (event.getNewCurrent() != 0) {
++                        return;
++                    }
++                }
++                // CraftBukkit end
+                 worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockRedstoneTorch.LIT, false), 3);
+                 if (a(worldserver, blockposition, true)) {
+                     worldserver.triggerEffect(1502, blockposition, 0);
+@@ -71,6 +89,15 @@
+                 }
+             }
+         } else if (!flag && !a(worldserver, blockposition, false)) {
++            // CraftBukkit start
++            if (oldCurrent != 15) {
++                event.setNewCurrent(15);
++                manager.callEvent(event);
++                if (event.getNewCurrent() != 15) {
++                    return;
++                }
++            }
++            // CraftBukkit end
+             worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockRedstoneTorch.LIT, true), 3);
+         }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockRedstoneWire.patch

@@ -0,0 +1,29 @@
+--- a/net/minecraft/server/BlockRedstoneWire.java
++++ b/net/minecraft/server/BlockRedstoneWire.java
+@@ -9,6 +9,8 @@
+ import java.util.Set;
+ import javax.annotation.Nullable;
+ 
++import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
++
+ public class BlockRedstoneWire extends Block {
+ 
+     public static final BlockStateEnum<BlockPropertyRedstoneSide> NORTH = BlockProperties.X;
+@@ -213,7 +215,16 @@
+     private void a(World world, BlockPosition blockposition, IBlockData iblockdata) {
+         int i = this.a(world, blockposition);
+ 
+-        if ((Integer) iblockdata.get(BlockRedstoneWire.POWER) != i) {
++        // CraftBukkit start
++        int oldPower = (Integer) iblockdata.get(BlockRedstoneWire.POWER);
++        if (oldPower != i) {
++            BlockRedstoneEvent event = new BlockRedstoneEvent(world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()), oldPower, i);
++            world.getServer().getPluginManager().callEvent(event);
++
++            i = event.getNewCurrent();
++        }
++        if (oldPower != i) {
++            // CraftBukkit end
+             if (world.getType(blockposition) == iblockdata) {
+                 world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockRedstoneWire.POWER, i), 2);
+             }

paper-server/nms-patches/net/minecraft/world/level/block/BlockReed.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/server/BlockReed.java
++++ b/net/minecraft/server/BlockReed.java
+@@ -39,7 +39,7 @@
+                 int j = (Integer) iblockdata.get(BlockReed.AGE);
+ 
+                 if (j == 15) {
+-                    worldserver.setTypeUpdate(blockposition.up(), this.getBlockData());
++                    org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockGrowEvent(worldserver, blockposition.up(), this.getBlockData()); // CraftBukkit
+                     worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockReed.AGE, 0), 4);
+                 } else {
+                     worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockReed.AGE, j + 1), 4);

paper-server/nms-patches/net/minecraft/world/level/block/BlockSapling.patch

@@ -0,0 +1,53 @@
+--- a/net/minecraft/server/BlockSapling.java
++++ b/net/minecraft/server/BlockSapling.java
+@@ -2,11 +2,19 @@
+ 
+ import java.util.Random;
+ 
++// CraftBukkit start
++import org.bukkit.Location;
++import org.bukkit.TreeType;
++import org.bukkit.block.BlockState;
++import org.bukkit.event.world.StructureGrowEvent;
++// CraftBukkit end
++
+ public class BlockSapling extends BlockPlant implements IBlockFragilePlantElement {
+ 
+     public static final BlockStateInteger STAGE = BlockProperties.aA;
+     protected static final VoxelShape b = Block.a(2.0D, 0.0D, 2.0D, 14.0D, 12.0D, 14.0D);
+     private final WorldGenTreeProvider c;
++    public static TreeType treeType; // CraftBukkit
+ 
+     protected BlockSapling(WorldGenTreeProvider worldgentreeprovider, BlockBase.Info blockbase_info) {
+         super(blockbase_info);
+@@ -22,7 +30,30 @@
+     @Override
+     public void tick(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, Random random) {
+         if (worldserver.getLightLevel(blockposition.up()) >= 9 && random.nextInt(7) == 0) {
++            // CraftBukkit start
++            worldserver.captureTreeGeneration = true;
++            // CraftBukkit end
+             this.grow(worldserver, blockposition, iblockdata, random);
++            // CraftBukkit start
++            worldserver.captureTreeGeneration = false;
++            if (worldserver.capturedBlockStates.size() > 0) {
++                TreeType treeType = BlockSapling.treeType;
++                BlockSapling.treeType = null;
++                Location location = new Location(worldserver.getWorld(), blockposition.getX(), blockposition.getY(), blockposition.getZ());
++                java.util.List<BlockState> blocks = new java.util.ArrayList<>(worldserver.capturedBlockStates.values());
++                worldserver.capturedBlockStates.clear();
++                StructureGrowEvent event = null;
++                if (treeType != null) {
++                    event = new StructureGrowEvent(location, treeType, false, null, blocks);
++                    org.bukkit.Bukkit.getPluginManager().callEvent(event);
++                }
++                if (event == null || !event.isCancelled()) {
++                    for (BlockState blockstate : blocks) {
++                        blockstate.update(true);
++                    }
++                }
++            }
++            // CraftBukkit end
+         }
+ 
+     }

paper-server/nms-patches/net/minecraft/world/level/block/BlockScaffolding.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/server/BlockScaffolding.java
++++ b/net/minecraft/server/BlockScaffolding.java
+@@ -73,7 +73,7 @@
+         int i = a((IBlockAccess) worldserver, blockposition);
+         IBlockData iblockdata1 = (IBlockData) ((IBlockData) iblockdata.set(BlockScaffolding.a, i)).set(BlockScaffolding.c, this.a(worldserver, blockposition, i));
+ 
+-        if ((Integer) iblockdata1.get(BlockScaffolding.a) == 7) {
++        if ((Integer) iblockdata1.get(BlockScaffolding.a) == 7 && !org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(worldserver, blockposition, Blocks.AIR.getBlockData()).isCancelled()) { // CraftBukkit - BlockFadeEvent
+             if ((Integer) iblockdata.get(BlockScaffolding.a) == 7) {
+                 worldserver.addEntity(new EntityFallingBlock(worldserver, (double) blockposition.getX() + 0.5D, (double) blockposition.getY(), (double) blockposition.getZ() + 0.5D, (IBlockData) iblockdata1.set(BlockScaffolding.b, false)));
+             } else {

paper-server/nms-patches/net/minecraft/world/level/block/BlockSnow.patch

@@ -0,0 +1,14 @@
+--- a/net/minecraft/server/BlockSnow.java
++++ b/net/minecraft/server/BlockSnow.java
+@@ -67,6 +67,11 @@
+     @Override
+     public void tick(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, Random random) {
+         if (worldserver.getBrightness(EnumSkyBlock.BLOCK, blockposition) > 11) {
++            // CraftBukkit start
++            if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(worldserver, blockposition, Blocks.AIR.getBlockData()).isCancelled()) {
++                return;
++            }
++            // CraftBukkit end
+             c(iblockdata, (World) worldserver, blockposition);
+             worldserver.a(blockposition, false);
+         }

paper-server/nms-patches/net/minecraft/world/level/block/BlockSoil.patch

@@ -0,0 +1,67 @@
+--- a/net/minecraft/server/BlockSoil.java
++++ b/net/minecraft/server/BlockSoil.java
+@@ -3,6 +3,11 @@
+ import java.util.Iterator;
+ import java.util.Random;
+ 
++// CraftBukkit start
++import org.bukkit.event.entity.EntityInteractEvent;
++import org.bukkit.craftbukkit.event.CraftEventFactory;
++// CraftBukkit end
++
+ public class BlockSoil extends Block {
+ 
+     public static final BlockStateInteger MOISTURE = BlockProperties.aw;
+@@ -58,26 +63,49 @@
+ 
+         if (!a((IWorldReader) worldserver, blockposition) && !worldserver.isRainingAt(blockposition.up())) {
+             if (i > 0) {
+-                worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockSoil.MOISTURE, i - 1), 2);
++                org.bukkit.craftbukkit.event.CraftEventFactory.handleMoistureChangeEvent(worldserver, blockposition, (IBlockData) iblockdata.set(BlockSoil.MOISTURE, i - 1), 2); // CraftBukkit
+             } else if (!a((IBlockAccess) worldserver, blockposition)) {
+                 fade(iblockdata, worldserver, blockposition);
+             }
+         } else if (i < 7) {
+-            worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockSoil.MOISTURE, 7), 2);
++            org.bukkit.craftbukkit.event.CraftEventFactory.handleMoistureChangeEvent(worldserver, blockposition, (IBlockData) iblockdata.set(BlockSoil.MOISTURE, 7), 2); // CraftBukkit
+         }
+ 
+     }
+ 
+     @Override
+     public void fallOn(World world, BlockPosition blockposition, Entity entity, float f) {
++        super.fallOn(world, blockposition, entity, f); // CraftBukkit - moved here as game rules / events shouldn't affect fall damage.
+         if (!world.isClientSide && world.random.nextFloat() < f - 0.5F && entity instanceof EntityLiving && (entity instanceof EntityHuman || world.getGameRules().getBoolean(GameRules.MOB_GRIEFING)) && entity.getWidth() * entity.getWidth() * entity.getHeight() > 0.512F) {
++            // CraftBukkit start - Interact soil
++            org.bukkit.event.Cancellable cancellable;
++            if (entity instanceof EntityHuman) {
++                cancellable = CraftEventFactory.callPlayerInteractEvent((EntityHuman) entity, org.bukkit.event.block.Action.PHYSICAL, blockposition, null, null, null);
++            } else {
++                cancellable = new EntityInteractEvent(entity.getBukkitEntity(), world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
++                world.getServer().getPluginManager().callEvent((EntityInteractEvent) cancellable);
++            }
++
++            if (cancellable.isCancelled()) {
++                return;
++            }
++
++            if (CraftEventFactory.callEntityChangeBlockEvent(entity, blockposition, Blocks.DIRT.getBlockData()).isCancelled()) {
++                return;
++            }
++            // CraftBukkit end
+             fade(world.getType(blockposition), world, blockposition);
+         }
+ 
+-        super.fallOn(world, blockposition, entity, f);
++        // super.fallOn(world, blockposition, entity, f); // CraftBukkit - moved up
+     }
+ 
+     public static void fade(IBlockData iblockdata, World world, BlockPosition blockposition) {
++        // CraftBukkit start
++        if (CraftEventFactory.callBlockFadeEvent(world, blockposition, Blocks.DIRT.getBlockData()).isCancelled()) {
++            return;
++        }
++        // CraftBukkit end
+         world.setTypeUpdate(blockposition, a(iblockdata, Blocks.DIRT.getBlockData(), world, blockposition));
+     }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockSponge.patch

@@ -0,0 +1,103 @@
+--- a/net/minecraft/server/BlockSponge.java
++++ b/net/minecraft/server/BlockSponge.java
+@@ -3,6 +3,13 @@
+ import com.google.common.collect.Lists;
+ import java.util.Queue;
+ 
++// CraftBukkit start
++import java.util.List;
++import org.bukkit.craftbukkit.block.CraftBlockState;
++import org.bukkit.craftbukkit.util.BlockStateListPopulator;
++import org.bukkit.event.block.SpongeAbsorbEvent;
++// CraftBukkit end
++
+ public class BlockSponge extends Block {
+ 
+     protected BlockSponge(BlockBase.Info blockbase_info) {
+@@ -35,6 +42,7 @@
+ 
+         queue.add(new Tuple<>(blockposition, 0));
+         int i = 0;
++        BlockStateListPopulator blockList = new BlockStateListPopulator(world); // CraftBukkit - Use BlockStateListPopulator
+ 
+         while (!queue.isEmpty()) {
+             Tuple<BlockPosition, Integer> tuple = (Tuple) queue.poll();
+@@ -46,27 +54,31 @@
+             for (int l = 0; l < k; ++l) {
+                 EnumDirection enumdirection = aenumdirection[l];
+                 BlockPosition blockposition2 = blockposition1.shift(enumdirection);
+-                IBlockData iblockdata = world.getType(blockposition2);
+-                Fluid fluid = world.getFluid(blockposition2);
++                // CraftBukkit start
++                IBlockData iblockdata = blockList.getType(blockposition2);
++                Fluid fluid = blockList.getFluid(blockposition2);
++                // CraftBukkit end
+                 Material material = iblockdata.getMaterial();
+ 
+                 if (fluid.a((Tag) TagsFluid.WATER)) {
+-                    if (iblockdata.getBlock() instanceof IFluidSource && ((IFluidSource) iblockdata.getBlock()).removeFluid(world, blockposition2, iblockdata) != FluidTypes.EMPTY) {
++                    if (iblockdata.getBlock() instanceof IFluidSource && ((IFluidSource) iblockdata.getBlock()).removeFluid(blockList, blockposition2, iblockdata) != FluidTypes.EMPTY) { // CraftBukkit
+                         ++i;
+                         if (j < 6) {
+                             queue.add(new Tuple<>(blockposition2, j + 1));
+                         }
+                     } else if (iblockdata.getBlock() instanceof BlockFluids) {
+-                        world.setTypeAndData(blockposition2, Blocks.AIR.getBlockData(), 3);
++                        blockList.setTypeAndData(blockposition2, Blocks.AIR.getBlockData(), 3); // CraftBukkit
+                         ++i;
+                         if (j < 6) {
+                             queue.add(new Tuple<>(blockposition2, j + 1));
+                         }
+                     } else if (material == Material.WATER_PLANT || material == Material.REPLACEABLE_WATER_PLANT) {
+-                        TileEntity tileentity = iblockdata.getBlock().isTileEntity() ? world.getTileEntity(blockposition2) : null;
++                        // CraftBukkit start
++                        // TileEntity tileentity = iblockdata.getBlock().isTileEntity() ? world.getTileEntity(blockposition2) : null;
+ 
+-                        a(iblockdata, (GeneratorAccess) world, blockposition2, tileentity);
+-                        world.setTypeAndData(blockposition2, Blocks.AIR.getBlockData(), 3);
++                        // a(iblockdata, (GeneratorAccess) world, blockposition2, tileentity);
++                        blockList.setTypeAndData(blockposition2, Blocks.AIR.getBlockData(), 3);
++                        // CraftBukkit end
+                         ++i;
+                         if (j < 6) {
+                             queue.add(new Tuple<>(blockposition2, j + 1));
+@@ -79,6 +91,39 @@
+                 break;
+             }
+         }
++        // CraftBukkit start
++        List<CraftBlockState> blocks = blockList.getList(); // Is a clone
++        if (!blocks.isEmpty()) {
++            final org.bukkit.block.Block bblock = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
++
++            SpongeAbsorbEvent event = new SpongeAbsorbEvent(bblock, (List<org.bukkit.block.BlockState>) (List) blocks);
++            world.getServer().getPluginManager().callEvent(event);
++
++            if (event.isCancelled()) {
++                return false;
++            }
++
++            for (CraftBlockState block : blocks) {
++                BlockPosition blockposition2 = block.getPosition();
++                IBlockData iblockdata = world.getType(blockposition2);
++                Fluid fluid = world.getFluid(blockposition2);
++                Material material = iblockdata.getMaterial();
++
++                if (fluid.a(TagsFluid.WATER)) {
++                    if (iblockdata.getBlock() instanceof IFluidSource && ((IFluidSource) iblockdata.getBlock()).removeFluid(blockList, blockposition2, iblockdata) != FluidTypes.EMPTY) {
++                        // NOP
++                    } else if (iblockdata.getBlock() instanceof BlockFluids) {
++                        // NOP
++                    } else if (material == Material.WATER_PLANT || material == Material.REPLACEABLE_WATER_PLANT) {
++                        TileEntity tileentity = iblockdata.getBlock().isTileEntity() ? world.getTileEntity(blockposition2) : null;
++
++                        a(iblockdata, world, blockposition2, tileentity);
++                    }
++                }
++                world.setTypeAndData(blockposition2, block.getHandle(), block.getFlag());
++            }
++        }
++        // CraftBukkit end
+ 
+         return i > 0;
+     }

paper-server/nms-patches/net/minecraft/world/level/block/BlockStem.patch

@@ -0,0 +1,41 @@
+--- a/net/minecraft/server/BlockStem.java
++++ b/net/minecraft/server/BlockStem.java
+@@ -2,6 +2,8 @@
+ 
+ import java.util.Random;
+ 
++import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
++
+ public class BlockStem extends BlockPlant implements IBlockFragilePlantElement {
+ 
+     public static final BlockStateInteger AGE = BlockProperties.ai;
+@@ -34,14 +36,18 @@
+ 
+                 if (i < 7) {
+                     iblockdata = (IBlockData) iblockdata.set(BlockStem.AGE, i + 1);
+-                    worldserver.setTypeAndData(blockposition, iblockdata, 2);
++                    CraftEventFactory.handleBlockGrowEvent(worldserver, blockposition, iblockdata, 2); // CraftBukkit
+                 } else {
+                     EnumDirection enumdirection = EnumDirection.EnumDirectionLimit.HORIZONTAL.a(random);
+                     BlockPosition blockposition1 = blockposition.shift(enumdirection);
+                     IBlockData iblockdata1 = worldserver.getType(blockposition1.down());
+ 
+                     if (worldserver.getType(blockposition1).isAir() && (iblockdata1.a(Blocks.FARMLAND) || iblockdata1.a(Blocks.DIRT) || iblockdata1.a(Blocks.COARSE_DIRT) || iblockdata1.a(Blocks.PODZOL) || iblockdata1.a(Blocks.GRASS_BLOCK))) {
+-                        worldserver.setTypeUpdate(blockposition1, this.blockFruit.getBlockData());
++                        // CraftBukkit start
++                        if (!CraftEventFactory.handleBlockGrowEvent(worldserver, blockposition1, this.blockFruit.getBlockData())) {
++                            return;
++                        }
++                        // CraftBukkit end
+                         worldserver.setTypeUpdate(blockposition, (IBlockData) this.blockFruit.d().getBlockData().set(BlockFacingHorizontal.FACING, enumdirection));
+                     }
+                 }
+@@ -65,7 +71,7 @@
+         int i = Math.min(7, (Integer) iblockdata.get(BlockStem.AGE) + MathHelper.nextInt(worldserver.random, 2, 5));
+         IBlockData iblockdata1 = (IBlockData) iblockdata.set(BlockStem.AGE, i);
+ 
+-        worldserver.setTypeAndData(blockposition, iblockdata1, 2);
++        CraftEventFactory.handleBlockGrowEvent(worldserver, blockposition, iblockdata1, 2); // CraftBukkit
+         if (i == 7) {
+             iblockdata1.b(worldserver, blockposition, worldserver.random);
+         }

paper-server/nms-patches/net/minecraft/world/level/block/BlockSweetBerryBush.patch

@@ -0,0 +1,53 @@
+--- a/net/minecraft/server/BlockSweetBerryBush.java
++++ b/net/minecraft/server/BlockSweetBerryBush.java
+@@ -2,6 +2,14 @@
+ 
+ import java.util.Random;
+ 
++// CraftBukkit start
++import java.util.Collections;
++import org.bukkit.craftbukkit.block.CraftBlock;
++import org.bukkit.craftbukkit.event.CraftEventFactory;
++import org.bukkit.craftbukkit.inventory.CraftItemStack;
++import org.bukkit.event.player.PlayerHarvestBlockEvent;
++// CraftBukkit end
++
+ public class BlockSweetBerryBush extends BlockPlant implements IBlockFragilePlantElement {
+ 
+     public static final BlockStateInteger a = BlockProperties.ag;
+@@ -28,7 +36,7 @@
+         int i = (Integer) iblockdata.get(BlockSweetBerryBush.a);
+ 
+         if (i < 3 && random.nextInt(5) == 0 && worldserver.getLightLevel(blockposition.up(), 0) >= 9) {
+-            worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockSweetBerryBush.a, i + 1), 2);
++            CraftEventFactory.handleBlockGrowEvent(worldserver, blockposition, (IBlockData) iblockdata.set(BlockSweetBerryBush.a, i + 1), 2); // CraftBukkit
+         }
+ 
+     }
+@@ -42,7 +50,9 @@
+                 double d1 = Math.abs(entity.locZ() - entity.F);
+ 
+                 if (d0 >= 0.003000000026077032D || d1 >= 0.003000000026077032D) {
++                    CraftEventFactory.blockDamage = CraftBlock.at(world, blockposition); // CraftBukkit
+                     entity.damageEntity(DamageSource.SWEET_BERRY_BUSH, 1.0F);
++                    CraftEventFactory.blockDamage = null; // CraftBukkit
+                 }
+             }
+ 
+@@ -59,7 +69,15 @@
+         } else if (i > 1) {
+             int j = 1 + world.random.nextInt(2);
+ 
+-            a(world, blockposition, new ItemStack(Items.SWEET_BERRIES, j + (flag ? 1 : 0)));
++            // CraftBukkit start
++            PlayerHarvestBlockEvent event = CraftEventFactory.callPlayerHarvestBlockEvent(world, blockposition, entityhuman, Collections.singletonList(new ItemStack(Items.SWEET_BERRIES, j + (flag ? 1 : 0))));
++            if (event.isCancelled()) {
++                return EnumInteractionResult.SUCCESS; // We need to return a success either way, because making it PASS or FAIL will result in a bug where cancelling while harvesting w/ block in hand places block
++            }
++            for (org.bukkit.inventory.ItemStack itemStack : event.getItemsHarvested()) {
++                a(world, blockposition, CraftItemStack.asNMSCopy(itemStack));
++            }
++            // CraftBukkit end
+             world.playSound((EntityHuman) null, blockposition, SoundEffects.ITEM_SWEET_BERRIES_PICK_FROM_BUSH, SoundCategory.BLOCKS, 1.0F, 0.8F + world.random.nextFloat() * 0.4F);
+             world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockSweetBerryBush.a, 1), 2);
+             return EnumInteractionResult.a(world.isClientSide);

paper-server/nms-patches/net/minecraft/world/level/block/BlockTNT.patch

@@ -0,0 +1,14 @@
+--- a/net/minecraft/server/BlockTNT.java
++++ b/net/minecraft/server/BlockTNT.java
+@@ -94,6 +94,11 @@
+ 
+             if (iprojectile.isBurning()) {
+                 BlockPosition blockposition = movingobjectpositionblock.getBlockPosition();
++                // CraftBukkit start
++                if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(iprojectile, blockposition, Blocks.AIR.getBlockData()).isCancelled()) {
++                    return;
++                }
++                // CraftBukkit end
+ 
+                 a(world, blockposition, entity instanceof EntityLiving ? (EntityLiving) entity : null);
+                 world.a(blockposition, false);

paper-server/nms-patches/net/minecraft/world/level/block/BlockTallPlant.patch

@@ -0,0 +1,14 @@
+--- a/net/minecraft/server/BlockTallPlant.java
++++ b/net/minecraft/server/BlockTallPlant.java
+@@ -66,6 +66,11 @@
+     }
+ 
+     protected static void b(World world, BlockPosition blockposition, IBlockData iblockdata, EntityHuman entityhuman) {
++        // CraftBukkit start
++        if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockPhysicsEvent(world, blockposition).isCancelled()) {
++            return;
++        }
++        // CraftBukkit end
+         BlockPropertyDoubleBlockHalf blockpropertydoubleblockhalf = (BlockPropertyDoubleBlockHalf) iblockdata.get(BlockTallPlant.HALF);
+ 
+         if (blockpropertydoubleblockhalf == BlockPropertyDoubleBlockHalf.UPPER) {

paper-server/nms-patches/net/minecraft/world/level/block/BlockTrapdoor.patch

@@ -0,0 +1,31 @@
+--- a/net/minecraft/server/BlockTrapdoor.java
++++ b/net/minecraft/server/BlockTrapdoor.java
+@@ -2,6 +2,8 @@
+ 
+ import javax.annotation.Nullable;
+ 
++import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
++
+ public class BlockTrapdoor extends BlockFacingHorizontal implements IBlockWaterlogged {
+ 
+     public static final BlockStateBoolean OPEN = BlockProperties.u;
+@@ -88,6 +90,19 @@
+             boolean flag1 = world.isBlockIndirectlyPowered(blockposition);
+ 
+             if (flag1 != (Boolean) iblockdata.get(BlockTrapdoor.c)) {
++                // CraftBukkit start
++                org.bukkit.World bworld = world.getWorld();
++                org.bukkit.block.Block bblock = bworld.getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
++
++                int power = bblock.getBlockPower();
++                int oldPower = (Boolean) iblockdata.get(OPEN) ? 15 : 0;
++
++                if (oldPower == 0 ^ power == 0 || block.getBlockData().isPowerSource()) {
++                    BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(bblock, oldPower, power);
++                    world.getServer().getPluginManager().callEvent(eventRedstone);
++                    flag1 = eventRedstone.getNewCurrent() > 0;
++                }
++                // CraftBukkit end
+                 if ((Boolean) iblockdata.get(BlockTrapdoor.OPEN) != flag1) {
+                     iblockdata = (IBlockData) iblockdata.set(BlockTrapdoor.OPEN, flag1);
+                     this.a((EntityHuman) null, world, blockposition, flag1);

paper-server/nms-patches/net/minecraft/world/level/block/BlockTripwire.patch

@@ -0,0 +1,52 @@
+--- a/net/minecraft/server/BlockTripwire.java
++++ b/net/minecraft/server/BlockTripwire.java
+@@ -5,6 +5,8 @@
+ import java.util.Map;
+ import java.util.Random;
+ 
++import org.bukkit.event.entity.EntityInteractEvent; // CraftBukkit
++
+ public class BlockTripwire extends Block {
+ 
+     public static final BlockStateBoolean POWERED = BlockProperties.w;
+@@ -132,6 +134,40 @@
+             }
+         }
+ 
++        // CraftBukkit start - Call interact even when triggering connected tripwire
++        if (flag != flag1 && flag1 && (Boolean)iblockdata.get(ATTACHED)) {
++            org.bukkit.World bworld = world.getWorld();
++            org.bukkit.plugin.PluginManager manager = world.getServer().getPluginManager();
++            org.bukkit.block.Block block = bworld.getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
++            boolean allowed = false;
++
++            // If all of the events are cancelled block the tripwire trigger, else allow
++            for (Object object : list) {
++                if (object != null) {
++                    org.bukkit.event.Cancellable cancellable;
++
++                    if (object instanceof EntityHuman) {
++                        cancellable = org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerInteractEvent((EntityHuman) object, org.bukkit.event.block.Action.PHYSICAL, blockposition, null, null, null);
++                    } else if (object instanceof Entity) {
++                        cancellable = new EntityInteractEvent(((Entity) object).getBukkitEntity(), block);
++                        manager.callEvent((EntityInteractEvent) cancellable);
++                    } else {
++                        continue;
++                    }
++
++                    if (!cancellable.isCancelled()) {
++                        allowed = true;
++                        break;
++                    }
++                }
++            }
++
++            if (!allowed) {
++                return;
++            }
++        }
++        // CraftBukkit end
++
+         if (flag1 != flag) {
+             iblockdata = (IBlockData) iblockdata.set(BlockTripwire.POWERED, flag1);
+             world.setTypeAndData(blockposition, iblockdata, 3);

paper-server/nms-patches/net/minecraft/world/level/block/BlockTripwireHook.patch

@@ -0,0 +1,29 @@
+--- a/net/minecraft/server/BlockTripwireHook.java
++++ b/net/minecraft/server/BlockTripwireHook.java
+@@ -4,6 +4,8 @@
+ import java.util.Random;
+ import javax.annotation.Nullable;
+ 
++import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit
++
+ public class BlockTripwireHook extends Block {
+ 
+     public static final BlockStateDirection FACING = BlockFacingHorizontal.FACING;
+@@ -134,6 +136,17 @@
+             this.a(world, blockposition1, flag4, flag5, flag2, flag3);
+         }
+ 
++        // CraftBukkit start
++        org.bukkit.block.Block block = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
++
++        BlockRedstoneEvent eventRedstone = new BlockRedstoneEvent(block, 15, 0);
++        world.getServer().getPluginManager().callEvent(eventRedstone);
++
++        if (eventRedstone.getNewCurrent() > 0) {
++            return;
++        }
++        // CraftBukkit end
++
+         this.a(world, blockposition, flag4, flag5, flag2, flag3);
+         if (!flag) {
+             world.setTypeAndData(blockposition, (IBlockData) iblockdata3.set(BlockTripwireHook.FACING, enumdirection), 3);

paper-server/nms-patches/net/minecraft/world/level/block/BlockTurtleEgg.patch

@@ -0,0 +1,65 @@
+--- a/net/minecraft/server/BlockTurtleEgg.java
++++ b/net/minecraft/server/BlockTurtleEgg.java
+@@ -3,6 +3,12 @@
+ import java.util.Random;
+ import javax.annotation.Nullable;
+ 
++// CraftBukkit start
++import org.bukkit.event.entity.EntityInteractEvent;
++import org.bukkit.craftbukkit.block.CraftBlock;
++import org.bukkit.craftbukkit.event.CraftEventFactory;
++// CraftBukkit end
++
+ public class BlockTurtleEgg extends Block {
+ 
+     private static final VoxelShape c = Block.a(3.0D, 0.0D, 3.0D, 12.0D, 7.0D, 12.0D);
+@@ -36,6 +42,19 @@
+                 IBlockData iblockdata = world.getType(blockposition);
+ 
+                 if (iblockdata.a(Blocks.TURTLE_EGG)) {
++                    // CraftBukkit start - Step on eggs
++                    org.bukkit.event.Cancellable cancellable;
++                    if (entity instanceof EntityHuman) {
++                        cancellable = CraftEventFactory.callPlayerInteractEvent((EntityHuman) entity, org.bukkit.event.block.Action.PHYSICAL, blockposition, null, null, null);
++                    } else {
++                        cancellable = new EntityInteractEvent(entity.getBukkitEntity(), CraftBlock.at(world, blockposition));
++                        world.getServer().getPluginManager().callEvent((EntityInteractEvent) cancellable);
++                    }
++
++                    if (cancellable.isCancelled()) {
++                        return;
++                    }
++                    // CraftBukkit end
+                     this.a(world, blockposition, iblockdata);
+                 }
+             }
+@@ -62,9 +81,19 @@
+             int i = (Integer) iblockdata.get(BlockTurtleEgg.a);
+ 
+             if (i < 2) {
++                // CraftBukkit start - Call BlockGrowEvent
++                if (!CraftEventFactory.handleBlockGrowEvent(worldserver, blockposition, iblockdata.set(BlockTurtleEgg.a, i + 1), 2)) {
++                    return;
++                }
++                // CraftBukkit end
+                 worldserver.playSound((EntityHuman) null, blockposition, SoundEffects.ENTITY_TURTLE_EGG_CRACK, SoundCategory.BLOCKS, 0.7F, 0.9F + random.nextFloat() * 0.2F);
+-                worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockTurtleEgg.a, i + 1), 2);
++                // worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockTurtleEgg.a, i + 1), 2); // CraftBukkit - handled above
+             } else {
++                // CraftBukkit start - Call BlockFadeEvent
++                if (CraftEventFactory.callBlockFadeEvent(worldserver, blockposition, Blocks.AIR.getBlockData()).isCancelled()) {
++                    return;
++                }
++                // CraftBukkit end
+                 worldserver.playSound((EntityHuman) null, blockposition, SoundEffects.ENTITY_TURTLE_EGG_HATCH, SoundCategory.BLOCKS, 0.7F, 0.9F + random.nextFloat() * 0.2F);
+                 worldserver.a(blockposition, false);
+ 
+@@ -75,7 +104,7 @@
+                     entityturtle.setAgeRaw(-24000);
+                     entityturtle.setHomePos(blockposition);
+                     entityturtle.setPositionRotation((double) blockposition.getX() + 0.3D + (double) j * 0.2D, (double) blockposition.getY(), (double) blockposition.getZ() + 0.3D, 0.0F, 0.0F);
+-                    worldserver.addEntity(entityturtle);
++                    worldserver.addEntity(entityturtle, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.EGG); // CraftBukkit
+                 }
+             }
+         }

paper-server/nms-patches/net/minecraft/world/level/block/BlockVine.patch

@@ -0,0 +1,59 @@
+--- a/net/minecraft/server/BlockVine.java
++++ b/net/minecraft/server/BlockVine.java
+@@ -8,6 +8,8 @@
+ import java.util.stream.Collectors;
+ import javax.annotation.Nullable;
+ 
++import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
++
+ public class BlockVine extends Block {
+ 
+     public static final BlockStateBoolean UP = BlockSprawling.e;
+@@ -175,20 +177,24 @@
+                         BlockPosition blockposition3 = blockposition2.shift(enumdirection1);
+                         BlockPosition blockposition4 = blockposition2.shift(enumdirection2);
+ 
++                        // CraftBukkit start - Call BlockSpreadEvent
++                        BlockPosition source = blockposition;
++
+                         if (flag && a((IBlockAccess) worldserver, blockposition3, enumdirection1)) {
+-                            worldserver.setTypeAndData(blockposition2, (IBlockData) this.getBlockData().set(getDirection(enumdirection1), true), 2);
++                            CraftEventFactory.handleBlockSpreadEvent(worldserver, source, blockposition2, (IBlockData) this.getBlockData().set(getDirection(enumdirection1), true), 2);
+                         } else if (flag1 && a((IBlockAccess) worldserver, blockposition4, enumdirection2)) {
+-                            worldserver.setTypeAndData(blockposition2, (IBlockData) this.getBlockData().set(getDirection(enumdirection2), true), 2);
++                            CraftEventFactory.handleBlockSpreadEvent(worldserver, source, blockposition2, (IBlockData) this.getBlockData().set(getDirection(enumdirection2), true), 2);
+                         } else {
+                             EnumDirection enumdirection3 = enumdirection.opposite();
+ 
+                             if (flag && worldserver.isEmpty(blockposition3) && a((IBlockAccess) worldserver, blockposition.shift(enumdirection1), enumdirection3)) {
+-                                worldserver.setTypeAndData(blockposition3, (IBlockData) this.getBlockData().set(getDirection(enumdirection3), true), 2);
++                                CraftEventFactory.handleBlockSpreadEvent(worldserver, source, blockposition3, (IBlockData) this.getBlockData().set(getDirection(enumdirection3), true), 2);
+                             } else if (flag1 && worldserver.isEmpty(blockposition4) && a((IBlockAccess) worldserver, blockposition.shift(enumdirection2), enumdirection3)) {
+-                                worldserver.setTypeAndData(blockposition4, (IBlockData) this.getBlockData().set(getDirection(enumdirection3), true), 2);
++                                CraftEventFactory.handleBlockSpreadEvent(worldserver, source, blockposition4, (IBlockData) this.getBlockData().set(getDirection(enumdirection3), true), 2);
+                             } else if ((double) worldserver.random.nextFloat() < 0.05D && a((IBlockAccess) worldserver, blockposition2.up(), EnumDirection.UP)) {
+-                                worldserver.setTypeAndData(blockposition2, (IBlockData) this.getBlockData().set(BlockVine.UP, true), 2);
++                                CraftEventFactory.handleBlockSpreadEvent(worldserver, source, blockposition2, (IBlockData) this.getBlockData().set(BlockVine.UP, true), 2);
+                             }
++                            // CraftBukkit end
+                         }
+                     } else if (a((IBlockAccess) worldserver, blockposition2, enumdirection)) {
+                         worldserver.setTypeAndData(blockposition, (IBlockData) iblockdata.set(getDirection(enumdirection), true), 2);
+@@ -218,7 +224,7 @@
+                         }
+ 
+                         if (this.canSpread(iblockdata2)) {
+-                            worldserver.setTypeAndData(blockposition1, iblockdata2, 2);
++                            CraftEventFactory.handleBlockSpreadEvent(worldserver, blockposition, blockposition1, iblockdata2, 2); // CraftBukkit
+                         }
+ 
+                         return;
+@@ -233,7 +239,7 @@
+                         IBlockData iblockdata4 = this.a(iblockdata, iblockdata3, random);
+ 
+                         if (iblockdata3 != iblockdata4 && this.canSpread(iblockdata4)) {
+-                            worldserver.setTypeAndData(blockposition2, iblockdata4, 2);
++                            CraftEventFactory.handleBlockSpreadEvent(worldserver, blockposition, blockposition2, iblockdata4, 2); // CraftBukkit
+                         }
+                     }
+                 }

paper-server/nms-patches/net/minecraft/world/level/block/BlockWaterLily.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/server/BlockWaterLily.java
++++ b/net/minecraft/server/BlockWaterLily.java
+@@ -11,7 +11,7 @@
+     @Override
+     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
+         super.a(iblockdata, world, blockposition, entity);
+-        if (world instanceof WorldServer && entity instanceof EntityBoat) {
++        if (world instanceof WorldServer && entity instanceof EntityBoat && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(entity, blockposition, Blocks.AIR.getBlockData()).isCancelled()) { // CraftBukkit
+             world.a(new BlockPosition(blockposition), true, entity);
+         }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockWitherRose.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/server/BlockWitherRose.java
++++ b/net/minecraft/server/BlockWitherRose.java
+@@ -18,7 +18,7 @@
+                 EntityLiving entityliving = (EntityLiving) entity;
+ 
+                 if (!entityliving.isInvulnerable(DamageSource.WITHER)) {
+-                    entityliving.addEffect(new MobEffect(MobEffects.WITHER, 40));
++                    entityliving.addEffect(new MobEffect(MobEffects.WITHER, 40), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.WITHER_ROSE); // CraftBukkit
+                 }
+             }
+ 

paper-server/nms-patches/net/minecraft/world/level/block/BlockWitherSkull.patch

@@ -0,0 +1,64 @@
+--- a/net/minecraft/server/BlockWitherSkull.java
++++ b/net/minecraft/server/BlockWitherSkull.java
+@@ -3,6 +3,11 @@
+ import java.util.Iterator;
+ import javax.annotation.Nullable;
+ 
++// CraftBukkit start
++import org.bukkit.craftbukkit.util.BlockStateListPopulator;
++import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason;
++// CraftBukkit end
++
+ public class BlockWitherSkull extends BlockSkull {
+ 
+     @Nullable
+@@ -26,6 +31,7 @@
+     }
+ 
+     public static void a(World world, BlockPosition blockposition, TileEntitySkull tileentityskull) {
++        if (world.captureBlockStates) return; // CraftBukkit
+         if (!world.isClientSide) {
+             IBlockData iblockdata = tileentityskull.getBlock();
+             boolean flag = iblockdata.a(Blocks.WITHER_SKELETON_SKULL) || iblockdata.a(Blocks.WITHER_SKELETON_WALL_SKULL);
+@@ -35,12 +41,14 @@
+                 ShapeDetector.ShapeDetectorCollection shapedetector_shapedetectorcollection = shapedetector.a(world, blockposition);
+ 
+                 if (shapedetector_shapedetectorcollection != null) {
++                    // CraftBukkit start - Use BlockStateListPopulator
++                    BlockStateListPopulator blockList = new BlockStateListPopulator(world);
+                     for (int i = 0; i < shapedetector.c(); ++i) {
+                         for (int j = 0; j < shapedetector.b(); ++j) {
+                             ShapeDetectorBlock shapedetectorblock = shapedetector_shapedetectorcollection.a(i, j, 0);
+ 
+-                            world.setTypeAndData(shapedetectorblock.getPosition(), Blocks.AIR.getBlockData(), 2);
+-                            world.triggerEffect(2001, shapedetectorblock.getPosition(), Block.getCombinedId(shapedetectorblock.a()));
++                            blockList.setTypeAndData(shapedetectorblock.getPosition(), Blocks.AIR.getBlockData(), 2); // CraftBukkit
++                            // world.triggerEffect(2001, shapedetectorblock.getPosition(), Block.getCombinedId(shapedetectorblock.a())); // CraftBukkit
+                         }
+                     }
+ 
+@@ -50,6 +58,15 @@
+                     entitywither.setPositionRotation((double) blockposition1.getX() + 0.5D, (double) blockposition1.getY() + 0.55D, (double) blockposition1.getZ() + 0.5D, shapedetector_shapedetectorcollection.getFacing().n() == EnumDirection.EnumAxis.X ? 0.0F : 90.0F, 0.0F);
+                     entitywither.aA = shapedetector_shapedetectorcollection.getFacing().n() == EnumDirection.EnumAxis.X ? 0.0F : 90.0F;
+                     entitywither.beginSpawnSequence();
++                    // CraftBukkit start
++                    if (!world.addEntity(entitywither, SpawnReason.BUILD_WITHER)) {
++                        return;
++                    }
++                    for (BlockPosition pos : blockList.getBlocks()) {
++                        world.triggerEffect(2001, pos, Block.getCombinedId(world.getType(pos)));
++                    }
++                    blockList.updateList();
++                    // CraftBukkit end
+                     Iterator iterator = world.a(EntityPlayer.class, entitywither.getBoundingBox().g(50.0D)).iterator();
+ 
+                     while (iterator.hasNext()) {
+@@ -58,7 +75,7 @@
+                         CriterionTriggers.n.a(entityplayer, (Entity) entitywither);
+                     }
+ 
+-                    world.addEntity(entitywither);
++                    // world.addEntity(entitywither); // CraftBukkit - moved up
+ 
+                     for (int k = 0; k < shapedetector.c(); ++k) {
+                         for (int l = 0; l < shapedetector.b(); ++l) {

paper-server/nms-patches/net/minecraft/world/level/block/entity/TileEntity.patch

@@ -0,0 +1,62 @@
+--- a/net/minecraft/server/TileEntity.java
++++ b/net/minecraft/server/TileEntity.java
+@@ -5,8 +5,18 @@
+ import org.apache.logging.log4j.Logger;
+ import org.apache.logging.log4j.util.Supplier;
+ 
++// CraftBukkit start
++import org.bukkit.craftbukkit.persistence.CraftPersistentDataContainer;
++import org.bukkit.craftbukkit.persistence.CraftPersistentDataTypeRegistry;
++import org.bukkit.inventory.InventoryHolder;
++// CraftBukkit end
++
+ public abstract class TileEntity {
+ 
++    // CraftBukkit start - data containers
++    private static final CraftPersistentDataTypeRegistry DATA_TYPE_REGISTRY = new CraftPersistentDataTypeRegistry();
++    public CraftPersistentDataContainer persistentDataContainer;
++    // CraftBukkit end
+     private static final Logger LOGGER = LogManager.getLogger();
+     private final TileEntityTypes<?> tileType;
+     @Nullable
+@@ -38,6 +48,14 @@
+ 
+     public void load(IBlockData iblockdata, NBTTagCompound nbttagcompound) {
+         this.position = new BlockPosition(nbttagcompound.getInt("x"), nbttagcompound.getInt("y"), nbttagcompound.getInt("z"));
++        // CraftBukkit start - read container
++        this.persistentDataContainer = new CraftPersistentDataContainer(DATA_TYPE_REGISTRY);
++
++        NBTBase persistentDataTag = nbttagcompound.get("PublicBukkitValues");
++        if (persistentDataTag instanceof NBTTagCompound) {
++            this.persistentDataContainer.putAll((NBTTagCompound) persistentDataTag);
++        }
++        // CraftBukkit end
+     }
+ 
+     public NBTTagCompound save(NBTTagCompound nbttagcompound) {
+@@ -54,6 +72,11 @@
+             nbttagcompound.setInt("x", this.position.getX());
+             nbttagcompound.setInt("y", this.position.getY());
+             nbttagcompound.setInt("z", this.position.getZ());
++            // CraftBukkit start - store container
++            if (this.persistentDataContainer != null && !this.persistentDataContainer.isEmpty()) {
++                nbttagcompound.set("PublicBukkitValues", this.persistentDataContainer.toTagCompound());
++            }
++            // CraftBukkit end
+             return nbttagcompound;
+         }
+     }
+@@ -169,4 +192,13 @@
+                     }, this::getPosition});
+         }
+     }
++
++    // CraftBukkit start - add method
++    public InventoryHolder getOwner() {
++        if (world == null) return null;
++        org.bukkit.block.BlockState state = world.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ()).getState();
++        if (state instanceof InventoryHolder) return (InventoryHolder) state;
++        return null;
++    }
++    // CraftBukkit end
+ }

paper-server/nms-patches/net/minecraft/world/level/block/entity/TileEntityBanner.patch

@@ -0,0 +1,14 @@
+--- a/net/minecraft/server/TileEntityBanner.java
++++ b/net/minecraft/server/TileEntityBanner.java
+@@ -70,6 +70,11 @@
+         }
+ 
+         this.patterns = nbttagcompound.getList("Patterns", 10);
++        // CraftBukkit start
++        while (this.patterns.size() > 20) {
++            this.patterns.remove(20);
++        }
++        // CraftBukkit end
+         this.h = null;
+         this.g = true;
+     }

paper-server/nms-patches/net/minecraft/world/level/block/entity/TileEntityBarrel.patch

@@ -0,0 +1,61 @@
+--- a/net/minecraft/server/TileEntityBarrel.java
++++ b/net/minecraft/server/TileEntityBarrel.java
+@@ -1,7 +1,49 @@
+ package net.minecraft.server;
+ 
++// CraftBukkit start
++import java.util.ArrayList;
++import java.util.List;
++import org.bukkit.craftbukkit.entity.CraftHumanEntity;
++import org.bukkit.entity.HumanEntity;
++// CraftBukkit end
++
+ public class TileEntityBarrel extends TileEntityLootable {
+ 
++    // CraftBukkit start - add fields and methods
++    public List<HumanEntity> transaction = new ArrayList<>();
++    private int maxStack = MAX_STACK;
++    public boolean opened;
++
++    @Override
++    public List<ItemStack> getContents() {
++        return this.items;
++    }
++
++    @Override
++    public void onOpen(CraftHumanEntity who) {
++        transaction.add(who);
++    }
++
++    @Override
++    public void onClose(CraftHumanEntity who) {
++        transaction.remove(who);
++    }
++
++    @Override
++    public List<HumanEntity> getViewers() {
++        return transaction;
++    }
++
++    @Override
++    public int getMaxStackSize() {
++       return maxStack;
++    }
++
++    @Override
++    public void setMaxStackSize(int i) {
++        maxStack = i;
++    }
++    // CraftBukkit end
+     private NonNullList<ItemStack> items;
+     private int b;
+ 
+@@ -100,7 +142,7 @@
+                 return;
+             }
+ 
+-            boolean flag = (Boolean) iblockdata.get(BlockBarrel.OPEN);
++            boolean flag = (Boolean) iblockdata.get(BlockBarrel.OPEN) && !opened; // CraftBukkit - only set flag if Barrel isn't set open by API.
+ 
+             if (flag) {
+                 this.playOpenSound(iblockdata, SoundEffects.BLOCK_BARREL_CLOSE);

paper-server/nms-patches/net/minecraft/world/level/block/entity/TileEntityBeacon.patch

@@ -0,0 +1,133 @@
+--- a/net/minecraft/server/TileEntityBeacon.java
++++ b/net/minecraft/server/TileEntityBeacon.java
+@@ -8,6 +8,11 @@
+ import java.util.stream.Collectors;
+ import javax.annotation.Nullable;
+ 
++// CraftBukkit start
++import org.bukkit.craftbukkit.potion.CraftPotionUtil;
++import org.bukkit.potion.PotionEffect;
++// CraftBukkit end
++
+ public class TileEntityBeacon extends TileEntity implements ITileInventory, ITickable {
+ 
+     public static final MobEffectList[][] a = new MobEffectList[][]{{MobEffects.FASTER_MOVEMENT, MobEffects.FASTER_DIG}, {MobEffects.RESISTANCE, MobEffects.JUMP}, {MobEffects.INCREASE_DAMAGE}, {MobEffects.REGENERATION}};
+@@ -24,6 +29,15 @@
+     public IChatBaseComponent customName;
+     public ChestLock chestLock;
+     private final IContainerProperties containerProperties;
++    // CraftBukkit start - add fields and methods
++    public PotionEffect getPrimaryEffect() {
++        return (this.primaryEffect != null) ? CraftPotionUtil.toBukkit(new MobEffect(this.primaryEffect, getLevel(), getAmplification(), true, true)) : null;
++    }
++
++    public PotionEffect getSecondaryEffect() {
++        return (hasSecondaryEffect()) ? CraftPotionUtil.toBukkit(new MobEffect(this.secondaryEffect, getLevel(), getAmplification(), true, true)) : null;
++    }
++    // CraftBukkit end
+ 
+     public TileEntityBeacon() {
+         super(TileEntityTypes.BEACON);
+@@ -192,39 +206,78 @@
+         super.al_();
+     }
+ 
+-    private void applyEffects() {
+-        if (!this.world.isClientSide && this.primaryEffect != null) {
+-            double d0 = (double) (this.levels * 10 + 10);
++    // CraftBukkit start - split into components
++    private byte getAmplification() {
++        {
+             byte b0 = 0;
+ 
+             if (this.levels >= 4 && this.primaryEffect == this.secondaryEffect) {
+                 b0 = 1;
+             }
+ 
++            return b0;
++        }
++    }
++
++    private int getLevel() {
++        {
+             int i = (9 + this.levels * 2) * 20;
++            return i;
++        }
++    }
++
++    public List getHumansInRange() {
++        {
++            double d0 = (double) (this.levels * 10 + 10);
++
+             AxisAlignedBB axisalignedbb = (new AxisAlignedBB(this.position)).g(d0).b(0.0D, (double) this.world.getBuildHeight(), 0.0D);
+             List<EntityHuman> list = this.world.a(EntityHuman.class, axisalignedbb);
++
++            return list;
++        }
++    }
++
++    private void applyEffect(List list, MobEffectList effects, int i, int b0) {
++        {
+             Iterator iterator = list.iterator();
+ 
+             EntityHuman entityhuman;
+ 
+             while (iterator.hasNext()) {
+                 entityhuman = (EntityHuman) iterator.next();
+-                entityhuman.addEffect(new MobEffect(this.primaryEffect, i, b0, true, true));
++                entityhuman.addEffect(new MobEffect(effects, i, b0, true, true), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.BEACON);
+             }
++        }
++    }
+ 
++    private boolean hasSecondaryEffect() {
++        {
+             if (this.levels >= 4 && this.primaryEffect != this.secondaryEffect && this.secondaryEffect != null) {
+-                iterator = list.iterator();
+-
+-                while (iterator.hasNext()) {
+-                    entityhuman = (EntityHuman) iterator.next();
+-                    entityhuman.addEffect(new MobEffect(this.secondaryEffect, i, 0, true, true));
+-                }
++                return true;
+             }
+ 
++            return false;
+         }
+     }
+ 
++    private void applyEffects() {
++        if (!this.world.isClientSide && this.primaryEffect != null) {
++            double d0 = (double) (this.levels * 10 + 10);
++            byte b0 = getAmplification();
++
++            int i = getLevel();
++            List list = getHumansInRange();
++
++            applyEffect(list, this.primaryEffect, i, b0);
++
++            if (hasSecondaryEffect()) {
++                applyEffect(list, this.secondaryEffect, i, 0);
++            }
++        }
++
++    }
++    // CraftBukkit end
++
+     public void a(SoundEffect soundeffect) {
+         this.world.playSound((EntityHuman) null, this.position, soundeffect, SoundCategory.BLOCKS, 1.0F, 1.0F);
+     }
+@@ -254,8 +307,11 @@
+     @Override
+     public void load(IBlockData iblockdata, NBTTagCompound nbttagcompound) {
+         super.load(iblockdata, nbttagcompound);
+-        this.primaryEffect = b(nbttagcompound.getInt("Primary"));
+-        this.secondaryEffect = b(nbttagcompound.getInt("Secondary"));
++        // CraftBukkit start - persist manually set non-default beacon effects (SPIGOT-3598)
++        this.primaryEffect = MobEffectList.fromId(nbttagcompound.getInt("Primary"));
++        this.secondaryEffect = MobEffectList.fromId(nbttagcompound.getInt("Secondary"));
++        this.levels = nbttagcompound.getInt("Levels"); // SPIGOT-5053, use where available
++        // CraftBukkit end
+         if (nbttagcompound.hasKeyOfType("CustomName", 8)) {
+             this.customName = IChatBaseComponent.ChatSerializer.a(nbttagcompound.getString("CustomName"));
+         }

paper-server/nms-patches/net/minecraft/world/level/block/entity/TileEntityBeehive.patch

@@ -0,0 +1,153 @@
+--- a/net/minecraft/server/TileEntityBeehive.java
++++ b/net/minecraft/server/TileEntityBeehive.java
+@@ -10,6 +10,7 @@
+     private final List<TileEntityBeehive.HiveBee> bees = Lists.newArrayList();
+     @Nullable
+     public BlockPosition flowerPos = null;
++    public int maxBees = 3; // CraftBukkit - allow setting max amount of bees a hive can hold
+ 
+     public TileEntityBeehive() {
+         super(TileEntityTypes.BEEHIVE);
+@@ -49,7 +50,7 @@
+     }
+ 
+     public boolean isFull() {
+-        return this.bees.size() == 3;
++        return this.bees.size() == this.maxBees; // CraftBukkit
+     }
+ 
+     public void a(@Nullable EntityHuman entityhuman, IBlockData iblockdata, TileEntityBeehive.ReleaseStatus tileentitybeehive_releasestatus) {
+@@ -66,7 +67,7 @@
+ 
+                     if (entityhuman.getPositionVector().distanceSquared(entity.getPositionVector()) <= 16.0D) {
+                         if (!this.isSedated()) {
+-                            entitybee.setGoalTarget(entityhuman);
++                            entitybee.setGoalTarget(entityhuman, org.bukkit.event.entity.EntityTargetEvent.TargetReason.CLOSEST_PLAYER, true); // CraftBukkit
+                         } else {
+                             entitybee.setCannotEnterHiveTicks(400);
+                         }
+@@ -78,10 +79,16 @@
+     }
+ 
+     private List<Entity> releaseBees(IBlockData iblockdata, TileEntityBeehive.ReleaseStatus tileentitybeehive_releasestatus) {
++        // CraftBukkit start - This allows us to bypass the night/rain/emergency check
++        return releaseBees(iblockdata, tileentitybeehive_releasestatus, false);
++    }
++
++    public List<Entity> releaseBees(IBlockData iblockdata, TileEntityBeehive.ReleaseStatus tileentitybeehive_releasestatus, boolean force) {
+         List<Entity> list = Lists.newArrayList();
+ 
+         this.bees.removeIf((tileentitybeehive_hivebee) -> {
+-            return this.releaseBee(iblockdata, tileentitybeehive_hivebee, list, tileentitybeehive_releasestatus);
++            return this.releaseBee(iblockdata, tileentitybeehive_hivebee, list, tileentitybeehive_releasestatus, force);
++            // CraftBukkit end
+         });
+         return list;
+     }
+@@ -107,7 +114,19 @@
+     }
+ 
+     public void a(Entity entity, boolean flag, int i) {
+-        if (this.bees.size() < 3) {
++        if (this.bees.size() < this.maxBees) { // CraftBukkit
++            // CraftBukkit start
++            if (this.world != null) {
++                org.bukkit.event.entity.EntityEnterBlockEvent event = new org.bukkit.event.entity.EntityEnterBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, getPosition()));
++                org.bukkit.Bukkit.getPluginManager().callEvent(event);
++                if (event.isCancelled()) {
++                    if (entity instanceof EntityBee) {
++                        ((EntityBee) entity).setCannotEnterHiveTicks(400);
++                    }
++                    return;
++                }
++            }
++            // CraftBukkit end
+             entity.stopRiding();
+             entity.ejectPassengers();
+             NBTTagCompound nbttagcompound = new NBTTagCompound();
+@@ -133,7 +152,13 @@
+     }
+ 
+     private boolean releaseBee(IBlockData iblockdata, TileEntityBeehive.HiveBee tileentitybeehive_hivebee, @Nullable List<Entity> list, TileEntityBeehive.ReleaseStatus tileentitybeehive_releasestatus) {
+-        if ((this.world.isNight() || this.world.isRaining()) && tileentitybeehive_releasestatus != TileEntityBeehive.ReleaseStatus.EMERGENCY) {
++        // CraftBukkit start - This allows us to bypass the night/rain/emergency check
++        return releaseBee(iblockdata, tileentitybeehive_hivebee, list, tileentitybeehive_releasestatus, false);
++    }
++
++    private boolean releaseBee(IBlockData iblockdata, TileEntityBeehive.HiveBee tileentitybeehive_hivebee, @Nullable List<Entity> list, TileEntityBeehive.ReleaseStatus tileentitybeehive_releasestatus, boolean force) {
++        if (!force && (this.world.isNight() || this.world.isRaining()) && tileentitybeehive_releasestatus != TileEntityBeehive.ReleaseStatus.EMERGENCY) {
++            // CraftBukkit end
+             return false;
+         } else {
+             BlockPosition blockposition = this.getPosition();
+@@ -157,6 +182,18 @@
+                     if (!entity.getEntityType().a((Tag) TagsEntity.BEEHIVE_INHABITORS)) {
+                         return false;
+                     } else {
++                        // CraftBukkit start
++                        if (entity instanceof EntityBee) {
++                            float f = entity.getWidth();
++                            double d0 = flag ? 0.0D : 0.55D + (double) (f / 2.0F);
++                            double d1 = (double) blockposition.getX() + 0.5D + d0 * (double) enumdirection.getAdjacentX();
++                            double d2 = (double) blockposition.getY() + 0.5D - (double) (entity.getHeight() / 2.0F);
++                            double d3 = (double) blockposition.getZ() + 0.5D + d0 * (double) enumdirection.getAdjacentZ();
++
++                            entity.setPositionRotation(d1, d2, d3, entity.yaw, entity.pitch);
++                        }
++                        if (!this.world.addEntity(entity, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.BEEHIVE)) return false; // CraftBukkit - SpawnReason, moved from below
++                        // CraftBukkit end
+                         if (entity instanceof EntityBee) {
+                             EntityBee entitybee = (EntityBee) entity;
+ 
+@@ -186,6 +223,7 @@
+                                 list.add(entitybee);
+                             }
+ 
++                            /* // CraftBukkit start
+                             float f = entity.getWidth();
+                             double d0 = flag ? 0.0D : 0.55D + (double) (f / 2.0F);
+                             double d1 = (double) blockposition.getX() + 0.5D + d0 * (double) enumdirection.getAdjacentX();
+@@ -193,10 +231,11 @@
+                             double d3 = (double) blockposition.getZ() + 0.5D + d0 * (double) enumdirection.getAdjacentZ();
+ 
+                             entity.setPositionRotation(d1, d2, d3, entity.yaw, entity.pitch);
++                             */ // CraftBukkit end
+                         }
+ 
+                         this.world.playSound((EntityHuman) null, blockposition, SoundEffects.BLOCK_BEEHIVE_EXIT, SoundCategory.BLOCKS, 1.0F, 1.0F);
+-                        return this.world.addEntity(entity);
++                        return true; // return this.world.addEntity(entity); // CraftBukkit - moved up
+                     }
+                 } else {
+                     return false;
+@@ -234,6 +273,10 @@
+ 
+                 if (this.releaseBee(iblockdata, tileentitybeehive_hivebee, (List) null, tileentitybeehive_releasestatus)) {
+                     iterator.remove();
++                    // CraftBukkit start
++                } else {
++                    tileentitybeehive_hivebee.ticksInHive = tileentitybeehive_hivebee.minOccupationTicks / 2; // Not strictly Vanilla behaviour in cases where bees cannot spawn but still reasonable
++                    // CraftBukkit end
+                 }
+             }
+         }
+@@ -276,6 +319,11 @@
+             this.flowerPos = GameProfileSerializer.b(nbttagcompound.getCompound("FlowerPos"));
+         }
+ 
++        // CraftBukkit start
++        if (nbttagcompound.hasKey("Bukkit.MaxEntities")) {
++            this.maxBees = nbttagcompound.getInt("Bukkit.MaxEntities");
++        }
++        // CraftBukkit end
+     }
+ 
+     @Override
+@@ -285,6 +333,7 @@
+         if (this.x()) {
+             nbttagcompound.set("FlowerPos", GameProfileSerializer.a(this.flowerPos));
+         }
++        nbttagcompound.setInt("Bukkit.MaxEntities", this.maxBees); // CraftBukkit
+ 
+         return nbttagcompound;
+     }

paper-server/nms-patches/net/minecraft/world/level/block/entity/TileEntityBrewingStand.patch

@@ -0,0 +1,112 @@
+--- a/net/minecraft/server/TileEntityBrewingStand.java
++++ b/net/minecraft/server/TileEntityBrewingStand.java
+@@ -4,6 +4,16 @@
+ import java.util.Iterator;
+ import javax.annotation.Nullable;
+ 
++// CraftBukkit start
++import java.util.List;
++import org.bukkit.craftbukkit.entity.CraftHumanEntity;
++import org.bukkit.craftbukkit.inventory.CraftItemStack;
++import org.bukkit.entity.HumanEntity;
++import org.bukkit.event.inventory.BrewEvent;
++import org.bukkit.event.inventory.BrewingStandFuelEvent;
++import org.bukkit.inventory.InventoryHolder;
++// CraftBukkit end
++
+ public class TileEntityBrewingStand extends TileEntityContainer implements IWorldInventory, ITickable {
+ 
+     private static final int[] b = new int[]{3};
+@@ -15,6 +25,36 @@
+     private Item k;
+     public int fuelLevel;
+     protected final IContainerProperties a;
++    // CraftBukkit start - add fields and methods
++    private int lastTick = MinecraftServer.currentTick;
++    public List<HumanEntity> transaction = new java.util.ArrayList<HumanEntity>();
++    private int maxStack = 64;
++
++    public void onOpen(CraftHumanEntity who) {
++        transaction.add(who);
++    }
++
++    public void onClose(CraftHumanEntity who) {
++        transaction.remove(who);
++    }
++
++    public List<HumanEntity> getViewers() {
++        return transaction;
++    }
++
++    public List<ItemStack> getContents() {
++        return this.items;
++    }
++
++    @Override
++    public int getMaxStackSize() {
++        return maxStack;
++    }
++
++    public void setMaxStackSize(int size) {
++        maxStack = size;
++    }
++    // CraftBukkit end
+ 
+     public TileEntityBrewingStand() {
+         super(TileEntityTypes.BREWING_STAND);
+@@ -83,8 +123,19 @@
+         ItemStack itemstack = (ItemStack) this.items.get(4);
+ 
+         if (this.fuelLevel <= 0 && itemstack.getItem() == Items.BLAZE_POWDER) {
+-            this.fuelLevel = 20;
+-            itemstack.subtract(1);
++            // CraftBukkit start
++            BrewingStandFuelEvent event = new BrewingStandFuelEvent(world.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ()), CraftItemStack.asCraftMirror(itemstack), 20);
++            this.world.getServer().getPluginManager().callEvent(event);
++
++            if (event.isCancelled()) {
++                return;
++            }
++
++            this.fuelLevel = event.getFuelPower();
++            if (this.fuelLevel > 0 && event.isConsuming()) {
++                itemstack.subtract(1);
++            }
++            // CraftBukkit end
+             this.update();
+         }
+ 
+@@ -92,9 +143,14 @@
+         boolean flag1 = this.brewTime > 0;
+         ItemStack itemstack1 = (ItemStack) this.items.get(3);
+ 
++        // CraftBukkit start - Use wall time instead of ticks for brewing
++        int elapsedTicks = MinecraftServer.currentTick - this.lastTick;
++        this.lastTick = MinecraftServer.currentTick;
++
+         if (flag1) {
+-            --this.brewTime;
+-            boolean flag2 = this.brewTime == 0;
++            this.brewTime -= elapsedTicks;
++            boolean flag2 = this.brewTime <= 0; // == -> <=
++            // CraftBukkit end
+ 
+             if (flag2 && flag) {
+                 this.j();
+@@ -168,6 +224,16 @@
+ 
+     private void j() {
+         ItemStack itemstack = (ItemStack) this.items.get(3);
++        // CraftBukkit start
++        InventoryHolder owner = this.getOwner();
++        if (owner != null) {
++            BrewEvent event = new BrewEvent(world.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ()), (org.bukkit.inventory.BrewerInventory) owner.getInventory(), this.fuelLevel);
++            org.bukkit.Bukkit.getPluginManager().callEvent(event);
++            if (event.isCancelled()) {
++                return;
++            }
++        }
++        // CraftBukkit end
+ 
+         for (int i = 0; i < 3; ++i) {
+             this.items.set(i, PotionBrewer.d(itemstack, (ItemStack) this.items.get(i)));

paper-server/nms-patches/net/minecraft/world/level/block/entity/TileEntityCampfire.patch

@@ -0,0 +1,36 @@
+--- a/net/minecraft/server/TileEntityCampfire.java
++++ b/net/minecraft/server/TileEntityCampfire.java
+@@ -4,6 +4,12 @@
+ import java.util.Random;
+ import javax.annotation.Nullable;
+ 
++// CraftBukkit start
++import org.bukkit.craftbukkit.block.CraftBlock;
++import org.bukkit.craftbukkit.inventory.CraftItemStack;
++import org.bukkit.event.block.BlockCookEvent;
++// CraftBukkit end
++
+ public class TileEntityCampfire extends TileEntity implements Clearable, ITickable {
+ 
+     private final NonNullList<ItemStack> items;
+@@ -55,6 +61,20 @@
+                     }).orElse(itemstack);
+                     BlockPosition blockposition = this.getPosition();
+ 
++                    // CraftBukkit start - fire BlockCookEvent
++                    CraftItemStack source = CraftItemStack.asCraftMirror(itemstack);
++                    org.bukkit.inventory.ItemStack result = CraftItemStack.asBukkitCopy(itemstack1);
++
++                    BlockCookEvent blockCookEvent = new BlockCookEvent(CraftBlock.at(this.world, this.position), source, result);
++                    this.world.getServer().getPluginManager().callEvent(blockCookEvent);
++
++                    if (blockCookEvent.isCancelled()) {
++                        return;
++                    }
++
++                    result = blockCookEvent.getResult();
++                    itemstack1 = CraftItemStack.asNMSCopy(result);
++                    // CraftBukkit end
+                     InventoryUtils.dropItem(this.world, (double) blockposition.getX(), (double) blockposition.getY(), (double) blockposition.getZ(), itemstack1);
+                     this.items.set(i, ItemStack.b);
+                     this.k();