add remapped patches as a testsoftspoon

1 files changed, 2159 insertions, 0 deletions

diff --git a/patch-remap/mache-spigotflower/net/minecraft/server/level/ServerLevel.java.patch b/patch-remap/mache-spigotflower/net/minecraft/server/level/ServerLevel.java.patch
new file mode 100644
index 0000000000..dc29b1cb79
--- /dev/null
+++ b/patch-remap/mache-spigotflower/net/minecraft/server/level/ServerLevel.java.patch
@@ -0,0 +1,2159 @@
+--- a/net/minecraft/server/level/ServerLevel.java
++++ b/net/minecraft/server/level/ServerLevel.java
+@@ -44,7 +44,6 @@
+ import net.minecraft.core.Direction;
+ import net.minecraft.core.Holder;
+ import net.minecraft.core.HolderSet;
+-import net.minecraft.core.RegistryAccess;
+ import net.minecraft.core.SectionPos;
+ import net.minecraft.core.particles.ParticleOptions;
+ import net.minecraft.core.registries.BuiltInRegistries;
+@@ -57,7 +56,6 @@
+ import net.minecraft.network.protocol.game.ClientboundDamageEventPacket;
+ import net.minecraft.network.protocol.game.ClientboundEntityEventPacket;
+ import net.minecraft.network.protocol.game.ClientboundExplodePacket;
+-import net.minecraft.network.protocol.game.ClientboundGameEventPacket;
+ import net.minecraft.network.protocol.game.ClientboundLevelEventPacket;
+ import net.minecraft.network.protocol.game.ClientboundLevelParticlesPacket;
+ import net.minecraft.network.protocol.game.ClientboundSetDefaultSpawnPositionPacket;
+@@ -103,7 +101,7 @@
+ import net.minecraft.world.entity.animal.horse.SkeletonHorse;
+ import net.minecraft.world.entity.boss.EnderDragonPart;
+ import net.minecraft.world.entity.boss.enderdragon.EnderDragon;
+-import net.minecraft.world.entity.npc.Npc;
++import net.minecraft.world.entity.npc.NPC;
+ import net.minecraft.world.entity.player.Player;
+ import net.minecraft.world.entity.raid.Raid;
+ import net.minecraft.world.entity.raid.Raids;
+@@ -121,11 +119,12 @@
+ import net.minecraft.world.level.StructureManager;
+ import net.minecraft.world.level.WorldGenLevel;
+ import net.minecraft.world.level.biome.Biome;
++import net.minecraft.world.level.biome.BiomeSource;
+ import net.minecraft.world.level.block.Block;
+ import net.minecraft.world.level.block.Blocks;
+ import net.minecraft.world.level.block.SnowLayerBlock;
+ import net.minecraft.world.level.block.entity.TickingBlockEntity;
+-import net.minecraft.world.level.block.state.BlockState;
++import net.minecraft.world.level.block.state.IBlockData;
+ import net.minecraft.world.level.chunk.ChunkAccess;
+ import net.minecraft.world.level.chunk.ChunkGenerator;
+ import net.minecraft.world.level.chunk.LevelChunk;
+@@ -143,7 +142,9 @@
+ import net.minecraft.world.level.gameevent.DynamicGameEventListener;
+ import net.minecraft.world.level.gameevent.GameEvent;
+ import net.minecraft.world.level.gameevent.GameEventDispatcher;
++import net.minecraft.world.level.levelgen.FlatLevelSource;
+ import net.minecraft.world.level.levelgen.Heightmap;
++import net.minecraft.world.level.levelgen.NoiseBasedChunkGenerator;
+ import net.minecraft.world.level.levelgen.structure.BoundingBox;
+ import net.minecraft.world.level.levelgen.structure.Structure;
+ import net.minecraft.world.level.levelgen.structure.StructureCheck;
+@@ -155,7 +156,7 @@
+ import net.minecraft.world.level.saveddata.maps.MapItemSavedData;
+ import net.minecraft.world.level.storage.DimensionDataStorage;
+ import net.minecraft.world.level.storage.LevelStorageSource;
+-import net.minecraft.world.level.storage.ServerLevelData;
++import net.minecraft.world.level.storage.PrimaryLevelData;
+ import net.minecraft.world.phys.AABB;
+ import net.minecraft.world.phys.Vec3;
+ import net.minecraft.world.phys.shapes.BooleanOp;
+@@ -163,6 +164,19 @@
+ import net.minecraft.world.phys.shapes.VoxelShape;
+ import net.minecraft.world.ticks.LevelTicks;
+ import org.slf4j.Logger;
++import org.bukkit.Bukkit;
++import org.bukkit.Location;
++import org.bukkit.WeatherType;
++import org.bukkit.craftbukkit.event.CraftEventFactory;
++import org.bukkit.craftbukkit.generator.CustomWorldChunkManager;
++import org.bukkit.craftbukkit.util.CraftNamespacedKey;
++import org.bukkit.craftbukkit.util.WorldUUID;
++import org.bukkit.event.entity.CreatureSpawnEvent;
++import org.bukkit.event.server.MapInitializeEvent;
++import org.bukkit.event.weather.LightningStrikeEvent;
++import org.bukkit.event.world.GenericGameEvent;
++import org.bukkit.event.world.TimeSkipEvent;
++// CraftBukkit end
+ 
+ public class ServerLevel extends Level implements WorldGenLevel {
+ 
+@@ -177,9 +191,9 @@
+     final List<ServerPlayer> players;
+     private final ServerChunkCache chunkSource;
+     private final MinecraftServer server;
+-    private final ServerLevelData serverLevelData;
++    public final PrimaryLevelData serverLevelData; // CraftBukkit - type
+     final EntityTickList entityTickList;
+-    private final PersistentEntitySectionManager<Entity> entityManager;
++    public final PersistentEntitySectionManager<Entity> entityManager;
+     private final GameEventDispatcher gameEventDispatcher;
+     public boolean noSave;
+     private final SleepStatus sleepStatus;
+@@ -202,12 +216,30 @@
+     private final boolean tickTime;
+     private final RandomSequences randomSequences;
+ 
+-    public ServerLevel(MinecraftServer minecraftserver, Executor executor, LevelStorageSource.LevelStorageAccess levelstoragesource_levelstorageaccess, ServerLevelData serverleveldata, ResourceKey<Level> resourcekey, LevelStem levelstem, ChunkProgressListener chunkprogresslistener, boolean flag, long i, List<CustomSpawner> list, boolean flag1, @Nullable RandomSequences randomsequences) {
+-        RegistryAccess.Frozen registryaccess_frozen = minecraftserver.registryAccess();
+-        Holder holder = levelstem.type();
++    // CraftBukkit start
++    public final LevelStorageSource.LevelStorageAccess convertable;
++    public final UUID uuid;
+ 
+-        Objects.requireNonNull(minecraftserver);
+-        super(serverleveldata, resourcekey, registryaccess_frozen, holder, minecraftserver::getProfiler, false, flag, i, minecraftserver.getMaxChainedNeighborUpdates());
++    public LevelChunk getChunkIfLoaded(int x, int z) {
++        return this.chunkSource.getChunk(x, z, false);
++    }
++
++    @Override
++    public ResourceKey<LevelStem> getTypeKey() {
++        return convertable.dimensionType;
++    }
++
++    // Add env and gen to constructor, IWorldDataServer -> WorldDataServer
++    public ServerLevel(MinecraftServer minecraftserver, Executor executor, LevelStorageSource.LevelStorageAccess convertable_conversionsession, PrimaryLevelData iworlddataserver, ResourceKey<Level> resourcekey, LevelStem worlddimension, ChunkProgressListener worldloadlistener, boolean flag, long i, List<CustomSpawner> list, boolean flag1, @Nullable RandomSequences randomsequences, org.bukkit.World.Environment env, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider) {
++        // IRegistryCustom.Dimension iregistrycustom_dimension = minecraftserver.registryAccess(); // CraftBukkit - decompile error
++        // Holder holder = worlddimension.type(); // CraftBukkit - decompile error
++
++        // Objects.requireNonNull(minecraftserver); // CraftBukkit - decompile error
++        super(iworlddataserver, resourcekey, minecraftserver.registryAccess(), worlddimension.type(), minecraftserver::getProfiler, false, flag, i, minecraftserver.getMaxChainedNeighborUpdates(), gen, biomeProvider, env);
++        this.pvpMode = minecraftserver.isPvpAllowed();
++        convertable = convertable_conversionsession;
++        uuid = WorldUUID.getUUID(convertable_conversionsession.levelDirectory.path().toFile());
++        // CraftBukkit end
+         this.players = Lists.newArrayList();
+         this.entityTickList = new EntityTickList();
+         this.blockTicks = new LevelTicks<>(this::isPositionTickingWithEntitiesLoaded, this.getProfilerSupplier());
+@@ -219,20 +251,36 @@
+         this.tickTime = flag1;
+         this.server = minecraftserver;
+         this.customSpawners = list;
+-        this.serverLevelData = serverleveldata;
+-        ChunkGenerator chunkgenerator = levelstem.generator();
++        this.serverLevelData = iworlddataserver;
++        ChunkGenerator chunkgenerator = worlddimension.generator();
++        // CraftBukkit start
++        serverLevelData.setWorld(this);
++
++        if (biomeProvider != null) {
++            BiomeSource worldChunkManager = new CustomWorldChunkManager(getWorld(), biomeProvider, server.registryAccess().registryOrThrow(Registries.BIOME));
++            if (chunkgenerator instanceof NoiseBasedChunkGenerator cga) {
++                chunkgenerator = new NoiseBasedChunkGenerator(worldChunkManager, cga.settings);
++            } else if (chunkgenerator instanceof FlatLevelSource cpf) {
++                chunkgenerator = new FlatLevelSource(cpf.settings(), worldChunkManager);
++            }
++        }
++
++        if (gen != null) {
++            chunkgenerator = new org.bukkit.craftbukkit.generator.CustomChunkGenerator(this, chunkgenerator, gen);
++        }
++        // CraftBukkit end
+         boolean flag2 = minecraftserver.forceSynchronousWrites();
+         DataFixer datafixer = minecraftserver.getFixerUpper();
+-        EntityPersistentStorage<Entity> entitypersistentstorage = new EntityStorage(this, levelstoragesource_levelstorageaccess.getDimensionPath(resourcekey).resolve("entities"), datafixer, flag2, minecraftserver);
++        EntityPersistentStorage<Entity> entitypersistentstorage = new EntityStorage(this, convertable_conversionsession.getDimensionPath(resourcekey).resolve("entities"), datafixer, flag2, minecraftserver);
+ 
+-        this.entityManager = new PersistentEntitySectionManager<>(Entity.class, new ServerLevel.EntityCallbacks(), entitypersistentstorage);
++        this.entityManager = new PersistentEntitySectionManager<>(Entity.class, new ServerLevel.a(), entitypersistentstorage);
+         StructureTemplateManager structuretemplatemanager = minecraftserver.getStructureManager();
+         int j = minecraftserver.getPlayerList().getViewDistance();
+         int k = minecraftserver.getPlayerList().getSimulationDistance();
+         PersistentEntitySectionManager persistententitysectionmanager = this.entityManager;
+ 
+         Objects.requireNonNull(this.entityManager);
+-        this.chunkSource = new ServerChunkCache(this, levelstoragesource_levelstorageaccess, datafixer, structuretemplatemanager, executor, chunkgenerator, j, k, flag2, chunkprogresslistener, persistententitysectionmanager::updateChunkStatus, () -> {
++        this.chunkSource = new ServerChunkCache(this, convertable_conversionsession, datafixer, structuretemplatemanager, executor, chunkgenerator, j, k, flag2, worldloadlistener, persistententitysectionmanager::updateChunkStatus, () -> {
+             return minecraftserver.overworld().getDataStorage();
+         });
+         this.chunkSource.getGeneratorState().ensureStructuresGenerated();
+@@ -242,15 +290,15 @@
+         this.getWorldBorder().setAbsoluteMaxSize(minecraftserver.getAbsoluteMaxWorldSize());
+         this.raids = (Raids) this.getDataStorage().computeIfAbsent(Raids.factory(this), Raids.getFileId(this.dimensionTypeRegistration()));
+         if (!minecraftserver.isSingleplayer()) {
+-            serverleveldata.setGameType(minecraftserver.getDefaultGameType());
++            iworlddataserver.setGameType(minecraftserver.getDefaultGameType());
+         }
+ 
+         long l = minecraftserver.getWorldData().worldGenOptions().seed();
+ 
+         this.structureCheck = new StructureCheck(this.chunkSource.chunkScanner(), this.registryAccess(), minecraftserver.getStructureManager(), resourcekey, chunkgenerator, this.chunkSource.randomState(), this, chunkgenerator.getBiomeSource(), l, datafixer);
+-        this.structureManager = new StructureManager(this, minecraftserver.getWorldData().worldGenOptions(), this.structureCheck);
+-        if (this.dimension() == Level.END && this.dimensionTypeRegistration().is(BuiltinDimensionTypes.END)) {
+-            this.dragonFight = new EndDragonFight(this, l, minecraftserver.getWorldData().endDragonFightData());
++        this.structureManager = new StructureManager(this, this.serverLevelData.worldGenOptions(), structureCheck); // CraftBukkit
++        if ((this.dimension() == Level.END && this.dimensionTypeRegistration().is(BuiltinDimensionTypes.END)) || env == org.bukkit.World.Environment.THE_END) { // CraftBukkit - Allow to create EnderDragonBattle in default and custom END
++            this.dragonFight = new EndDragonFight(this, this.serverLevelData.worldGenOptions().seed(), this.serverLevelData.endDragonFightData()); // CraftBukkit
+         } else {
+             this.dragonFight = null;
+         }
+@@ -260,44 +308,44 @@
+         this.randomSequences = (RandomSequences) Objects.requireNonNullElseGet(randomsequences, () -> {
+             return (RandomSequences) this.getDataStorage().computeIfAbsent(RandomSequences.factory(l), "random_sequences");
+         });
++        this.getCraftServer().addWorld(this.getWorld()); // CraftBukkit
+     }
+ 
+     /** @deprecated */
+     @Deprecated
+     @VisibleForTesting
+-    public void setDragonFight(@Nullable EndDragonFight enddragonfight) {
+-        this.dragonFight = enddragonfight;
++    public void setDragonFight(@Nullable EndDragonFight dragonFight) {
++        this.dragonFight = dragonFight;
+     }
+ 
+-    public void setWeatherParameters(int i, int j, boolean flag, boolean flag1) {
+-        this.serverLevelData.setClearWeatherTime(i);
+-        this.serverLevelData.setRainTime(j);
+-        this.serverLevelData.setThunderTime(j);
+-        this.serverLevelData.setRaining(flag);
+-        this.serverLevelData.setThundering(flag1);
++    public void setWeatherParameters(int clearTime, int weatherTime, boolean isRaining, boolean isThundering) {
++        this.serverLevelData.setClearWeatherTime(clearTime);
++        this.serverLevelData.setRainTime(weatherTime);
++        this.serverLevelData.setThunderTime(weatherTime);
++        this.serverLevelData.setRaining(isRaining);
++        this.serverLevelData.setThundering(isThundering);
+     }
+ 
+     @Override
+-    @Override
+-    public Holder<Biome> getUncachedNoiseBiome(int i, int j, int k) {
+-        return this.getChunkSource().getGenerator().getBiomeSource().getNoiseBiome(i, j, k, this.getChunkSource().randomState().sampler());
++    public Holder<Biome> getUncachedNoiseBiome(int x, int y, int z) {
++        return this.getChunkSource().getGenerator().getBiomeSource().getNoiseBiome(x, y, z, this.getChunkSource().randomState().sampler());
+     }
+ 
+     public StructureManager structureManager() {
+         return this.structureManager;
+     }
+ 
+-    public void tick(BooleanSupplier booleansupplier) {
+-        ProfilerFiller profilerfiller = this.getProfiler();
++    public void tick(BooleanSupplier hasTimeLeft) {
++        ProfilerFiller gameprofilerfiller = this.getProfiler();
+ 
+         this.handlingTick = true;
+         TickRateManager tickratemanager = this.tickRateManager();
+         boolean flag = tickratemanager.runsNormally();
+ 
+         if (flag) {
+-            profilerfiller.push("world border");
++            gameprofilerfiller.push("world border");
+             this.getWorldBorder().tick();
+-            profilerfiller.popPush("weather");
++            gameprofilerfiller.popPush("weather");
+             this.advanceWeatherCycle();
+         }
+ 
+@@ -305,12 +353,20 @@
+         long j;
+ 
+         if (this.sleepStatus.areEnoughSleeping(i) && this.sleepStatus.areEnoughDeepSleeping(i, this.players)) {
++            // CraftBukkit start
++            j = this.levelData.getDayTime() + 24000L;
++            TimeSkipEvent event = new TimeSkipEvent(this.getWorld(), TimeSkipEvent.SkipReason.NIGHT_SKIP, (j - j % 24000L) - this.getDayTime());
+             if (this.getGameRules().getBoolean(GameRules.RULE_DAYLIGHT)) {
+-                j = this.levelData.getDayTime() + 24000L;
+-                this.setDayTime(j - j % 24000L);
++                getCraftServer().getPluginManager().callEvent(event);
++                if (!event.isCancelled()) {
++                    this.setDayTime(this.getDayTime() + event.getSkipAmount());
++                }
+             }
+ 
+-            this.wakeUpAllPlayers();
++            if (!event.isCancelled()) {
++                this.wakeUpAllPlayers();
++            }
++            // CraftBukkit end
+             if (this.getGameRules().getBoolean(GameRules.RULE_WEATHER_CYCLE) && this.isRaining()) {
+                 this.resetWeatherCycle();
+             }
+@@ -321,52 +377,52 @@
+             this.tickTime();
+         }
+ 
+-        profilerfiller.popPush("tickPending");
++        gameprofilerfiller.popPush("tickPending");
+         if (!this.isDebug() && flag) {
+             j = this.getGameTime();
+-            profilerfiller.push("blockTicks");
++            gameprofilerfiller.push("blockTicks");
+             this.blockTicks.tick(j, 65536, this::tickBlock);
+-            profilerfiller.popPush("fluidTicks");
++            gameprofilerfiller.popPush("fluidTicks");
+             this.fluidTicks.tick(j, 65536, this::tickFluid);
+-            profilerfiller.pop();
++            gameprofilerfiller.pop();
+         }
+ 
+-        profilerfiller.popPush("raid");
++        gameprofilerfiller.popPush("raid");
+         if (flag) {
+             this.raids.tick();
+         }
+ 
+-        profilerfiller.popPush("chunkSource");
+-        this.getChunkSource().tick(booleansupplier, true);
+-        profilerfiller.popPush("blockEvents");
++        gameprofilerfiller.popPush("chunkSource");
++        this.getChunkSource().tick(hasTimeLeft, true);
++        gameprofilerfiller.popPush("blockEvents");
+         if (flag) {
+             this.runBlockEvents();
+         }
+ 
+         this.handlingTick = false;
+-        profilerfiller.pop();
+-        boolean flag1 = !this.players.isEmpty() || !this.getForcedChunks().isEmpty();
++        gameprofilerfiller.pop();
++        boolean flag1 = true || !this.players.isEmpty() || !this.getForcedChunks().isEmpty(); // CraftBukkit - this prevents entity cleanup, other issues on servers with no players
+ 
+         if (flag1) {
+             this.resetEmptyTime();
+         }
+ 
+         if (flag1 || this.emptyTime++ < 300) {
+-            profilerfiller.push("entities");
++            gameprofilerfiller.push("entities");
+             if (this.dragonFight != null && flag) {
+-                profilerfiller.push("dragonFight");
++                gameprofilerfiller.push("dragonFight");
+                 this.dragonFight.tick();
+-                profilerfiller.pop();
++                gameprofilerfiller.pop();
+             }
+ 
+             this.entityTickList.forEach((entity) -> {
+                 if (!entity.isRemoved()) {
+-                    if (this.shouldDiscardEntity(entity)) {
++                    if (false && this.shouldDiscardEntity(entity)) { // CraftBukkit - We prevent spawning in general, so this butchering is not needed
+                         entity.discard();
+                     } else if (!tickratemanager.isEntityFrozen(entity)) {
+-                        profilerfiller.push("checkDespawn");
++                        gameprofilerfiller.push("checkDespawn");
+                         entity.checkDespawn();
+-                        profilerfiller.pop();
++                        gameprofilerfiller.pop();
+                         if (this.chunkSource.chunkMap.getDistanceManager().inEntityTickingRange(entity.chunkPosition().toLong())) {
+                             Entity entity1 = entity.getVehicle();
+ 
+@@ -378,26 +434,25 @@
+                                 entity.stopRiding();
+                             }
+ 
+-                            profilerfiller.push("tick");
++                            gameprofilerfiller.push("tick");
+                             this.guardEntityTick(this::tickNonPassenger, entity);
+-                            profilerfiller.pop();
++                            gameprofilerfiller.pop();
+                         }
+                     }
+                 }
+             });
+-            profilerfiller.pop();
++            gameprofilerfiller.pop();
+             this.tickBlockEntities();
+         }
+ 
+-        profilerfiller.push("entityManagement");
++        gameprofilerfiller.push("entityManagement");
+         this.entityManager.tick();
+-        profilerfiller.pop();
++        gameprofilerfiller.pop();
+     }
+ 
+     @Override
+-    @Override
+-    public boolean shouldTickBlocksAt(long i) {
+-        return this.chunkSource.chunkMap.getDistanceManager().inBlockTickingRange(i);
++    public boolean shouldTickBlocksAt(long chunkPos) {
++        return this.chunkSource.chunkMap.getDistanceManager().inBlockTickingRange(chunkPos);
+     }
+ 
+     protected void tickTime() {
+@@ -413,185 +468,185 @@
+         }
+     }
+ 
+-    public void setDayTime(long i) {
+-        this.serverLevelData.setDayTime(i);
++    public void setDayTime(long time) {
++        this.serverLevelData.setDayTime(time);
+     }
+ 
+-    public void tickCustomSpawners(boolean flag, boolean flag1) {
++    public void tickCustomSpawners(boolean spawnEnemies, boolean spawnFriendlies) {
+         Iterator iterator = this.customSpawners.iterator();
+ 
+         while (iterator.hasNext()) {
+-            CustomSpawner customspawner = (CustomSpawner) iterator.next();
++            CustomSpawner mobspawner = (CustomSpawner) iterator.next();
+ 
+-            customspawner.tick(this, flag, flag1);
++            mobspawner.tick(this, spawnEnemies, spawnFriendlies);
+         }
+ 
+     }
+ 
+     private boolean shouldDiscardEntity(Entity entity) {
+-        return !this.server.isSpawningAnimals() && (entity instanceof Animal || entity instanceof WaterAnimal) ? true : !this.server.areNpcsEnabled() && entity instanceof Npc;
++        return !this.server.isSpawningAnimals() && (entity instanceof Animal || entity instanceof WaterAnimal) ? true : !this.server.areNpcsEnabled() && entity instanceof NPC;
+     }
+ 
+     private void wakeUpAllPlayers() {
+         this.sleepStatus.removeAllSleepers();
+-        ((List) this.players.stream().filter(LivingEntity::isSleeping).collect(Collectors.toList())).forEach((serverplayer) -> {
+-            serverplayer.stopSleepInBed(false, false);
++        (this.players.stream().filter(LivingEntity::isSleeping).collect(Collectors.toList())).forEach((entityplayer) -> { // CraftBukkit - decompile error
++            entityplayer.stopSleepInBed(false, false);
+         });
+     }
+ 
+-    public void tickChunk(LevelChunk levelchunk, int i) {
+-        ChunkPos chunkpos = levelchunk.getPos();
++    public void tickChunk(LevelChunk chunk, int randomTickSpeed) {
++        ChunkPos chunkcoordintpair = chunk.getPos();
+         boolean flag = this.isRaining();
+-        int j = chunkpos.getMinBlockX();
+-        int k = chunkpos.getMinBlockZ();
+-        ProfilerFiller profilerfiller = this.getProfiler();
++        int j = chunkcoordintpair.getMinBlockX();
++        int k = chunkcoordintpair.getMinBlockZ();
++        ProfilerFiller gameprofilerfiller = this.getProfiler();
+ 
+-        profilerfiller.push("thunder");
++        gameprofilerfiller.push("thunder");
+         if (flag && this.isThundering() && this.random.nextInt(100000) == 0) {
+-            BlockPos blockpos = this.findLightningTargetAround(this.getBlockRandomPos(j, 0, k, 15));
++            BlockPos blockposition = this.findLightningTargetAround(this.getBlockRandomPos(j, 0, k, 15));
+ 
+-            if (this.isRainingAt(blockpos)) {
+-                DifficultyInstance difficultyinstance = this.getCurrentDifficultyAt(blockpos);
+-                boolean flag1 = this.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && this.random.nextDouble() < (double) difficultyinstance.getEffectiveDifficulty() * 0.01D && !this.getBlockState(blockpos.below()).is(Blocks.LIGHTNING_ROD);
++            if (this.isRainingAt(blockposition)) {
++                DifficultyInstance difficultydamagescaler = this.getCurrentDifficultyAt(blockposition);
++                boolean flag1 = this.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && this.random.nextDouble() < (double) difficultydamagescaler.getEffectiveDifficulty() * 0.01D && !this.getBlockState(blockposition.below()).is(Blocks.LIGHTNING_ROD);
+ 
+                 if (flag1) {
+-                    SkeletonHorse skeletonhorse = (SkeletonHorse) EntityType.SKELETON_HORSE.create(this);
++                    SkeletonHorse entityhorseskeleton = (SkeletonHorse) EntityType.SKELETON_HORSE.create(this);
+ 
+-                    if (skeletonhorse != null) {
+-                        skeletonhorse.setTrap(true);
+-                        skeletonhorse.setAge(0);
+-                        skeletonhorse.setPos((double) blockpos.getX(), (double) blockpos.getY(), (double) blockpos.getZ());
+-                        this.addFreshEntity(skeletonhorse);
++                    if (entityhorseskeleton != null) {
++                        entityhorseskeleton.setTrap(true);
++                        entityhorseskeleton.setAge(0);
++                        entityhorseskeleton.setPos((double) blockposition.getX(), (double) blockposition.getY(), (double) blockposition.getZ());
++                        this.addFreshEntity(entityhorseskeleton, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.LIGHTNING); // CraftBukkit
+                     }
+                 }
+ 
+-                LightningBolt lightningbolt = (LightningBolt) EntityType.LIGHTNING_BOLT.create(this);
++                LightningBolt entitylightning = (LightningBolt) EntityType.LIGHTNING_BOLT.create(this);
+ 
+-                if (lightningbolt != null) {
+-                    lightningbolt.moveTo(Vec3.atBottomCenterOf(blockpos));
+-                    lightningbolt.setVisualOnly(flag1);
+-                    this.addFreshEntity(lightningbolt);
++                if (entitylightning != null) {
++                    entitylightning.moveTo(Vec3.atBottomCenterOf(blockposition));
++                    entitylightning.setVisualOnly(flag1);
++                    this.strikeLightning(entitylightning, org.bukkit.event.weather.LightningStrikeEvent.Cause.WEATHER); // CraftBukkit
+                 }
+             }
+         }
+ 
+-        profilerfiller.popPush("iceandsnow");
++        gameprofilerfiller.popPush("iceandsnow");
+ 
+-        for (int l = 0; l < i; ++l) {
++        for (int l = 0; l < randomTickSpeed; ++l) {
+             if (this.random.nextInt(48) == 0) {
+                 this.tickPrecipitation(this.getBlockRandomPos(j, 0, k, 15));
+             }
+         }
+ 
+-        profilerfiller.popPush("tickBlocks");
+-        if (i > 0) {
+-            LevelChunkSection[] alevelchunksection = levelchunk.getSections();
++        gameprofilerfiller.popPush("tickBlocks");
++        if (randomTickSpeed > 0) {
++            LevelChunkSection[] achunksection = chunk.getSections();
+ 
+-            for (int i1 = 0; i1 < alevelchunksection.length; ++i1) {
+-                LevelChunkSection levelchunksection = alevelchunksection[i1];
++            for (int i1 = 0; i1 < achunksection.length; ++i1) {
++                LevelChunkSection chunksection = achunksection[i1];
+ 
+-                if (levelchunksection.isRandomlyTicking()) {
+-                    int j1 = levelchunk.getSectionYFromSectionIndex(i1);
++                if (chunksection.isRandomlyTicking()) {
++                    int j1 = chunk.getSectionYFromSectionIndex(i1);
+                     int k1 = SectionPos.sectionToBlockCoord(j1);
+ 
+-                    for (int l1 = 0; l1 < i; ++l1) {
+-                        BlockPos blockpos1 = this.getBlockRandomPos(j, k1, k, 15);
++                    for (int l1 = 0; l1 < randomTickSpeed; ++l1) {
++                        BlockPos blockposition1 = this.getBlockRandomPos(j, k1, k, 15);
+ 
+-                        profilerfiller.push("randomTick");
+-                        BlockState blockstate = levelchunksection.getBlockState(blockpos1.getX() - j, blockpos1.getY() - k1, blockpos1.getZ() - k);
++                        gameprofilerfiller.push("randomTick");
++                        IBlockData iblockdata = chunksection.getBlockState(blockposition1.getX() - j, blockposition1.getY() - k1, blockposition1.getZ() - k);
+ 
+-                        if (blockstate.isRandomlyTicking()) {
+-                            blockstate.randomTick(this, blockpos1, this.random);
++                        if (iblockdata.isRandomlyTicking()) {
++                            iblockdata.randomTick(this, blockposition1, this.random);
+                         }
+ 
+-                        FluidState fluidstate = blockstate.getFluidState();
++                        FluidState fluid = iblockdata.getFluidState();
+ 
+-                        if (fluidstate.isRandomlyTicking()) {
+-                            fluidstate.randomTick(this, blockpos1, this.random);
++                        if (fluid.isRandomlyTicking()) {
++                            fluid.randomTick(this, blockposition1, this.random);
+                         }
+ 
+-                        profilerfiller.pop();
++                        gameprofilerfiller.pop();
+                     }
+                 }
+             }
+         }
+ 
+-        profilerfiller.pop();
++        gameprofilerfiller.pop();
+     }
+ 
+     @VisibleForTesting
+-    public void tickPrecipitation(BlockPos blockpos) {
+-        BlockPos blockpos1 = this.getHeightmapPos(Heightmap.Types.MOTION_BLOCKING, blockpos);
+-        BlockPos blockpos2 = blockpos1.below();
+-        Biome biome = (Biome) this.getBiome(blockpos1).value();
++    public void tickPrecipitation(BlockPos blockposition) {
++        BlockPos blockposition1 = this.getHeightmapPos(Heightmap.Types.MOTION_BLOCKING, blockposition);
++        BlockPos blockposition2 = blockposition1.below();
++        Biome biomebase = (Biome) this.getBiome(blockposition1).value();
+ 
+-        if (biome.shouldFreeze(this, blockpos2)) {
+-            this.setBlockAndUpdate(blockpos2, Blocks.ICE.defaultBlockState());
++        if (biomebase.shouldFreeze(this, blockposition2)) {
++            org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(this, blockposition2, Blocks.ICE.defaultBlockState(), null); // CraftBukkit
+         }
+ 
+         if (this.isRaining()) {
+             int i = this.getGameRules().getInt(GameRules.RULE_SNOW_ACCUMULATION_HEIGHT);
+ 
+-            if (i > 0 && biome.shouldSnow(this, blockpos1)) {
+-                BlockState blockstate = this.getBlockState(blockpos1);
++            if (i > 0 && biomebase.shouldSnow(this, blockposition1)) {
++                IBlockData iblockdata = this.getBlockState(blockposition1);
+ 
+-                if (blockstate.is(Blocks.SNOW)) {
+-                    int j = (Integer) blockstate.getValue(SnowLayerBlock.LAYERS);
++                if (iblockdata.is(Blocks.SNOW)) {
++                    int j = (Integer) iblockdata.getValue(SnowLayerBlock.LAYERS);
+ 
+                     if (j < Math.min(i, 8)) {
+-                        BlockState blockstate1 = (BlockState) blockstate.setValue(SnowLayerBlock.LAYERS, j + 1);
++                        IBlockData iblockdata1 = (IBlockData) iblockdata.setValue(SnowLayerBlock.LAYERS, j + 1);
+ 
+-                        Block.pushEntitiesUp(blockstate, blockstate1, this, blockpos1);
+-                        this.setBlockAndUpdate(blockpos1, blockstate1);
++                        Block.pushEntitiesUp(iblockdata, iblockdata1, this, blockposition1);
++                        org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(this, blockposition1, iblockdata1, null); // CraftBukkit
+                     }
+                 } else {
+-                    this.setBlockAndUpdate(blockpos1, Blocks.SNOW.defaultBlockState());
++                    org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(this, blockposition1, Blocks.SNOW.defaultBlockState(), null); // CraftBukkit
+                 }
+             }
+ 
+-            Biome.Precipitation biome_precipitation = biome.getPrecipitationAt(blockpos2);
++            Biome.Precipitation biomebase_precipitation = biomebase.getPrecipitationAt(blockposition2);
+ 
+-            if (biome_precipitation != Biome.Precipitation.NONE) {
+-                BlockState blockstate2 = this.getBlockState(blockpos2);
++            if (biomebase_precipitation != Biome.Precipitation.NONE) {
++                IBlockData iblockdata2 = this.getBlockState(blockposition2);
+ 
+-                blockstate2.getBlock().handlePrecipitation(blockstate2, this, blockpos2, biome_precipitation);
++                iblockdata2.getBlock().handlePrecipitation(iblockdata2, this, blockposition2, biomebase_precipitation);
+             }
+         }
+ 
+     }
+ 
+-    private Optional<BlockPos> findLightningRod(BlockPos blockpos) {
++    private Optional<BlockPos> findLightningRod(BlockPos pos) {
+         Optional<BlockPos> optional = this.getPoiManager().findClosest((holder) -> {
+             return holder.is(PoiTypes.LIGHTNING_ROD);
+-        }, (blockpos1) -> {
+-            return blockpos1.getY() == this.getHeight(Heightmap.Types.WORLD_SURFACE, blockpos1.getX(), blockpos1.getZ()) - 1;
+-        }, blockpos, 128, PoiManager.Occupancy.ANY);
++        }, (blockposition1) -> {
++            return blockposition1.getY() == this.getHeight(Heightmap.Types.WORLD_SURFACE, blockposition1.getX(), blockposition1.getZ()) - 1;
++        }, pos, 128, PoiManager.Occupancy.ANY);
+ 
+-        return optional.map((blockpos1) -> {
+-            return blockpos1.above(1);
++        return optional.map((blockposition1) -> {
++            return blockposition1.above(1);
+         });
+     }
+ 
+-    protected BlockPos findLightningTargetAround(BlockPos blockpos) {
+-        BlockPos blockpos1 = this.getHeightmapPos(Heightmap.Types.MOTION_BLOCKING, blockpos);
+-        Optional<BlockPos> optional = this.findLightningRod(blockpos1);
++    protected BlockPos findLightningTargetAround(BlockPos pos) {
++        BlockPos blockposition1 = this.getHeightmapPos(Heightmap.Types.MOTION_BLOCKING, pos);
++        Optional<BlockPos> optional = this.findLightningRod(blockposition1);
+ 
+         if (optional.isPresent()) {
+             return (BlockPos) optional.get();
+         } else {
+-            AABB aabb = AABB.encapsulatingFullBlocks(blockpos1, new BlockPos(blockpos1.atY(this.getMaxBuildHeight()))).inflate(3.0D);
+-            List<LivingEntity> list = this.getEntitiesOfClass(LivingEntity.class, aabb, (livingentity) -> {
+-                return livingentity != null && livingentity.isAlive() && this.canSeeSky(livingentity.blockPosition());
++            AABB axisalignedbb = AABB.encapsulatingFullBlocks(blockposition1, new BlockPos(blockposition1.atY(this.getMaxBuildHeight()))).inflate(3.0D);
++            List<LivingEntity> list = this.getEntitiesOfClass(LivingEntity.class, axisalignedbb, (entityliving) -> {
++                return entityliving != null && entityliving.isAlive() && this.canSeeSky(entityliving.blockPosition());
+             });
+ 
+             if (!list.isEmpty()) {
+                 return ((LivingEntity) list.get(this.random.nextInt(list.size()))).blockPosition();
+             } else {
+-                if (blockpos1.getY() == this.getMinBuildHeight() - 1) {
+-                    blockpos1 = blockpos1.above(2);
++                if (blockposition1.getY() == this.getMinBuildHeight() - 1) {
++                    blockposition1 = blockposition1.above(2);
+                 }
+ 
+-                return blockpos1;
++                return blockposition1;
+             }
+         }
+     }
+@@ -608,20 +663,20 @@
+         if (this.canSleepThroughNights()) {
+             if (!this.getServer().isSingleplayer() || this.getServer().isPublished()) {
+                 int i = this.getGameRules().getInt(GameRules.RULE_PLAYERS_SLEEPING_PERCENTAGE);
+-                MutableComponent mutablecomponent;
++                MutableComponent ichatmutablecomponent;
+ 
+                 if (this.sleepStatus.areEnoughSleeping(i)) {
+-                    mutablecomponent = Component.translatable("sleep.skipping_night");
++                    ichatmutablecomponent = Component.translatable("sleep.skipping_night");
+                 } else {
+-                    mutablecomponent = Component.translatable("sleep.players_sleeping", this.sleepStatus.amountSleeping(), this.sleepStatus.sleepersNeeded(i));
++                    ichatmutablecomponent = Component.translatable("sleep.players_sleeping", this.sleepStatus.amountSleeping(), this.sleepStatus.sleepersNeeded(i));
+                 }
+ 
+                 Iterator iterator = this.players.iterator();
+ 
+                 while (iterator.hasNext()) {
+-                    ServerPlayer serverplayer = (ServerPlayer) iterator.next();
++                    ServerPlayer entityplayer = (ServerPlayer) iterator.next();
+ 
+-                    serverplayer.displayClientMessage(mutablecomponent, true);
++                    entityplayer.displayClientMessage(ichatmutablecomponent, true);
+                 }
+ 
+             }
+@@ -636,7 +691,6 @@
+     }
+ 
+     @Override
+-    @Override
+     public ServerScoreboard getScoreboard() {
+         return this.server.getScoreboard();
+     }
+@@ -707,67 +761,102 @@
+             this.rainLevel = Mth.clamp(this.rainLevel, 0.0F, 1.0F);
+         }
+ 
++        /* CraftBukkit start
+         if (this.oRainLevel != this.rainLevel) {
+-            this.server.getPlayerList().broadcastAll(new ClientboundGameEventPacket(ClientboundGameEventPacket.RAIN_LEVEL_CHANGE, this.rainLevel), this.dimension());
++            this.server.getPlayerList().broadcastAll(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.RAIN_LEVEL_CHANGE, this.rainLevel), this.dimension());
+         }
+ 
+         if (this.oThunderLevel != this.thunderLevel) {
+-            this.server.getPlayerList().broadcastAll(new ClientboundGameEventPacket(ClientboundGameEventPacket.THUNDER_LEVEL_CHANGE, this.thunderLevel), this.dimension());
++            this.server.getPlayerList().broadcastAll(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.THUNDER_LEVEL_CHANGE, this.thunderLevel), this.dimension());
+         }
+ 
+         if (flag != this.isRaining()) {
+             if (flag) {
+-                this.server.getPlayerList().broadcastAll(new ClientboundGameEventPacket(ClientboundGameEventPacket.STOP_RAINING, 0.0F));
++                this.server.getPlayerList().broadcastAll(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.STOP_RAINING, 0.0F));
+             } else {
+-                this.server.getPlayerList().broadcastAll(new ClientboundGameEventPacket(ClientboundGameEventPacket.START_RAINING, 0.0F));
++                this.server.getPlayerList().broadcastAll(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.START_RAINING, 0.0F));
+             }
+ 
+-            this.server.getPlayerList().broadcastAll(new ClientboundGameEventPacket(ClientboundGameEventPacket.RAIN_LEVEL_CHANGE, this.rainLevel));
+-            this.server.getPlayerList().broadcastAll(new ClientboundGameEventPacket(ClientboundGameEventPacket.THUNDER_LEVEL_CHANGE, this.thunderLevel));
++            this.server.getPlayerList().broadcastAll(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.RAIN_LEVEL_CHANGE, this.rainLevel));
++            this.server.getPlayerList().broadcastAll(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.THUNDER_LEVEL_CHANGE, this.thunderLevel));
+         }
++        // */
++        for (int idx = 0; idx < this.players.size(); ++idx) {
++            if (((ServerPlayer) this.players.get(idx)).level() == this) {
++                ((ServerPlayer) this.players.get(idx)).tickWeather();
++            }
++        }
+ 
++        if (flag != this.isRaining()) {
++            // Only send weather packets to those affected
++            for (int idx = 0; idx < this.players.size(); ++idx) {
++                if (((ServerPlayer) this.players.get(idx)).level() == this) {
++                    ((ServerPlayer) this.players.get(idx)).setPlayerWeather((!flag ? WeatherType.DOWNFALL : WeatherType.CLEAR), false);
++                }
++            }
++        }
++        for (int idx = 0; idx < this.players.size(); ++idx) {
++            if (((ServerPlayer) this.players.get(idx)).level() == this) {
++                ((ServerPlayer) this.players.get(idx)).updateWeather(this.oRainLevel, this.rainLevel, this.oThunderLevel, this.thunderLevel);
++            }
++        }
++        // CraftBukkit end
++
+     }
+ 
+     @VisibleForTesting
+     public void resetWeatherCycle() {
+-        this.serverLevelData.setRainTime(0);
++        // CraftBukkit start
+         this.serverLevelData.setRaining(false);
+-        this.serverLevelData.setThunderTime(0);
++        // If we stop due to everyone sleeping we should reset the weather duration to some other random value.
++        // Not that everyone ever manages to get the whole server to sleep at the same time....
++        if (!this.serverLevelData.isRaining()) {
++            this.serverLevelData.setRainTime(0);
++        }
++        // CraftBukkit end
+         this.serverLevelData.setThundering(false);
++        // CraftBukkit start
++        // If we stop due to everyone sleeping we should reset the weather duration to some other random value.
++        // Not that everyone ever manages to get the whole server to sleep at the same time....
++        if (!this.serverLevelData.isThundering()) {
++            this.serverLevelData.setThunderTime(0);
++        }
++        // CraftBukkit end
+     }
+ 
+     public void resetEmptyTime() {
+         this.emptyTime = 0;
+     }
+ 
+-    private void tickFluid(BlockPos blockpos, Fluid fluid) {
+-        FluidState fluidstate = this.getFluidState(blockpos);
++    private void tickFluid(BlockPos pos, Fluid fluid) {
++        FluidState fluid = this.getFluidState(pos);
+ 
+-        if (fluidstate.is(fluid)) {
+-            fluidstate.tick(this, blockpos);
++        if (fluid.is(fluid)) {
++            fluid.tick(this, pos);
+         }
+ 
+     }
+ 
+-    private void tickBlock(BlockPos blockpos, Block block) {
+-        BlockState blockstate = this.getBlockState(blockpos);
++    private void tickBlock(BlockPos pos, Block block) {
++        IBlockData iblockdata = this.getBlockState(pos);
+ 
+-        if (blockstate.is(block)) {
+-            blockstate.tick(this, blockpos, this.random);
++        if (iblockdata.is(block)) {
++            iblockdata.tick(this, pos, this.random);
+         }
+ 
+     }
+ 
+     public void tickNonPassenger(Entity entity) {
+         entity.setOldPosAndRot();
+-        ProfilerFiller profilerfiller = this.getProfiler();
++        ProfilerFiller gameprofilerfiller = this.getProfiler();
+ 
+         ++entity.tickCount;
+         this.getProfiler().push(() -> {
+             return BuiltInRegistries.ENTITY_TYPE.getKey(entity.getType()).toString();
+         });
+-        profilerfiller.incrementCounter("tickNonPassenger");
++        gameprofilerfiller.incrementCounter("tickNonPassenger");
+         entity.tick();
++        entity.postTick(); // CraftBukkit
+         this.getProfiler().pop();
+         Iterator iterator = entity.getPassengers().iterator();
+ 
+@@ -779,91 +868,100 @@
+ 
+     }
+ 
+-    private void tickPassenger(Entity entity, Entity entity1) {
+-        if (!entity1.isRemoved() && entity1.getVehicle() == entity) {
+-            if (entity1 instanceof Player || this.entityTickList.contains(entity1)) {
+-                entity1.setOldPosAndRot();
+-                ++entity1.tickCount;
+-                ProfilerFiller profilerfiller = this.getProfiler();
++    private void tickPassenger(Entity ridingEntity, Entity passengerEntity) {
++        if (!passengerEntity.isRemoved() && passengerEntity.getVehicle() == ridingEntity) {
++            if (passengerEntity instanceof Player || this.entityTickList.contains(passengerEntity)) {
++                passengerEntity.setOldPosAndRot();
++                ++passengerEntity.tickCount;
++                ProfilerFiller gameprofilerfiller = this.getProfiler();
+ 
+-                profilerfiller.push(() -> {
+-                    return BuiltInRegistries.ENTITY_TYPE.getKey(entity1.getType()).toString();
++                gameprofilerfiller.push(() -> {
++                    return BuiltInRegistries.ENTITY_TYPE.getKey(passengerEntity.getType()).toString();
+                 });
+-                profilerfiller.incrementCounter("tickPassenger");
+-                entity1.rideTick();
+-                profilerfiller.pop();
+-                Iterator iterator = entity1.getPassengers().iterator();
++                gameprofilerfiller.incrementCounter("tickPassenger");
++                passengerEntity.rideTick();
++                passengerEntity.postTick(); // CraftBukkit
++                gameprofilerfiller.pop();
++                Iterator iterator = passengerEntity.getPassengers().iterator();
+ 
+                 while (iterator.hasNext()) {
+                     Entity entity2 = (Entity) iterator.next();
+ 
+-                    this.tickPassenger(entity1, entity2);
++                    this.tickPassenger(passengerEntity, entity2);
+                 }
+ 
+             }
+         } else {
+-            entity1.stopRiding();
++            passengerEntity.stopRiding();
+         }
+     }
+ 
+     @Override
+-    @Override
+-    public boolean mayInteract(Player player, BlockPos blockpos) {
+-        return !this.server.isUnderSpawnProtection(this, blockpos, player) && this.getWorldBorder().isWithinBounds(blockpos);
++    public boolean mayInteract(Player player, BlockPos pos) {
++        return !this.server.isUnderSpawnProtection(this, pos, player) && this.getWorldBorder().isWithinBounds(pos);
+     }
+ 
+-    public void save(@Nullable ProgressListener progresslistener, boolean flag, boolean flag1) {
+-        ServerChunkCache serverchunkcache = this.getChunkSource();
++    public void save(@Nullable ProgressListener progress, boolean flush, boolean skipSave) {
++        ServerChunkCache chunkproviderserver = this.getChunkSource();
+ 
+-        if (!flag1) {
+-            if (progresslistener != null) {
+-                progresslistener.progressStartNoAbort(Component.translatable("menu.savingLevel"));
++        if (!skipSave) {
++            org.bukkit.Bukkit.getPluginManager().callEvent(new org.bukkit.event.world.WorldSaveEvent(getWorld())); // CraftBukkit
++            if (progress != null) {
++                progress.progressStartNoAbort(Component.translatable("menu.savingLevel"));
+             }
+ 
+             this.saveLevelData();
+-            if (progresslistener != null) {
+-                progresslistener.progressStage(Component.translatable("menu.savingChunks"));
++            if (progress != null) {
++                progress.progressStage(Component.translatable("menu.savingChunks"));
+             }
+ 
+-            serverchunkcache.save(flag);
+-            if (flag) {
++            chunkproviderserver.save(flush);
++            if (flush) {
+                 this.entityManager.saveAll();
+             } else {
+                 this.entityManager.autoSave();
+             }
+ 
+         }
++
++        // CraftBukkit start - moved from MinecraftServer.saveChunks
++        ServerLevel worldserver1 = this;
++
++        serverLevelData.setWorldBorder(worldserver1.getWorldBorder().createSettings());
++        serverLevelData.setCustomBossEvents(this.server.getCustomBossEvents().save());
++        convertable.saveDataTag(this.server.registryAccess(), this.serverLevelData, this.server.getPlayerList().getSingleplayerData());
++        // CraftBukkit end
+     }
+ 
+     private void saveLevelData() {
+         if (this.dragonFight != null) {
+-            this.server.getWorldData().setEndDragonFightData(this.dragonFight.saveData());
++            this.serverLevelData.setEndDragonFightData(this.dragonFight.saveData()); // CraftBukkit
+         }
+ 
+         this.getChunkSource().getDataStorage().save();
+     }
+ 
+-    public <T extends Entity> List<? extends T> getEntities(EntityTypeTest<Entity, T> entitytypetest, Predicate<? super T> predicate) {
++    public <T extends Entity> List<? extends T> getEntities(EntityTypeTest<Entity, T> typeTest, Predicate<? super T> predicate) {
+         List<T> list = Lists.newArrayList();
+ 
+-        this.getEntities(entitytypetest, predicate, (List) list);
++        this.getEntities(typeTest, predicate, (List) list);
+         return list;
+     }
+ 
+-    public <T extends Entity> void getEntities(EntityTypeTest<Entity, T> entitytypetest, Predicate<? super T> predicate, List<? super T> list) {
+-        this.getEntities(entitytypetest, predicate, list, Integer.MAX_VALUE);
++    public <T extends Entity> void getEntities(EntityTypeTest<Entity, T> typeTest, Predicate<? super T> predicate, List<? super T> output) {
++        this.getEntities(typeTest, predicate, output, Integer.MAX_VALUE);
+     }
+ 
+-    public <T extends Entity> void getEntities(EntityTypeTest<Entity, T> entitytypetest, Predicate<? super T> predicate, List<? super T> list, int i) {
+-        this.getEntities().get(entitytypetest, (entity) -> {
++    public <T extends Entity> void getEntities(EntityTypeTest<Entity, T> typeTest, Predicate<? super T> predicate, List<? super T> output, int maxResults) {
++        this.getEntities().get(typeTest, (entity) -> {
+             if (predicate.test(entity)) {
+-                list.add(entity);
+-                if (list.size() >= i) {
+-                    return AbortableIterationConsumer.Continuation.ABORT;
++                output.add(entity);
++                if (output.size() >= maxResults) {
++                    return AbortableIterationConsumer.a.ABORT;
+                 }
+             }
+ 
+-            return AbortableIterationConsumer.Continuation.CONTINUE;
++            return AbortableIterationConsumer.a.CONTINUE;
+         });
+     }
+ 
+@@ -875,16 +973,16 @@
+         return this.getPlayers(predicate, Integer.MAX_VALUE);
+     }
+ 
+-    public List<ServerPlayer> getPlayers(Predicate<? super ServerPlayer> predicate, int i) {
++    public List<ServerPlayer> getPlayers(Predicate<? super ServerPlayer> predicate, int maxResults) {
+         List<ServerPlayer> list = Lists.newArrayList();
+         Iterator iterator = this.players.iterator();
+ 
+         while (iterator.hasNext()) {
+-            ServerPlayer serverplayer = (ServerPlayer) iterator.next();
++            ServerPlayer entityplayer = (ServerPlayer) iterator.next();
+ 
+-            if (predicate.test(serverplayer)) {
+-                list.add(serverplayer);
+-                if (list.size() >= i) {
++            if (predicate.test(entityplayer)) {
++                list.add(entityplayer);
++                if (list.size() >= maxResults) {
+                     return list;
+                 }
+             }
+@@ -901,93 +999,154 @@
+     }
+ 
+     @Override
+-    @Override
+     public boolean addFreshEntity(Entity entity) {
+-        return this.addEntity(entity);
++        // CraftBukkit start
++        return this.addFreshEntity(entity, CreatureSpawnEvent.SpawnReason.DEFAULT);
+     }
+ 
++    @Override
++    public boolean addFreshEntity(Entity entity, CreatureSpawnEvent.SpawnReason reason) {
++        return this.addEntity(entity, reason);
++        // CraftBukkit end
++    }
++
+     public boolean addWithUUID(Entity entity) {
+-        return this.addEntity(entity);
++        // CraftBukkit start
++        return this.addWithUUID(entity, CreatureSpawnEvent.SpawnReason.DEFAULT);
+     }
+ 
++    public boolean addWithUUID(Entity entity, CreatureSpawnEvent.SpawnReason reason) {
++        return this.addEntity(entity, reason);
++        // CraftBukkit end
++    }
++
+     public void addDuringTeleport(Entity entity) {
+-        this.addEntity(entity);
++        // CraftBukkit start
++        // SPIGOT-6415: Don't call spawn event for entities which travel trough worlds,
++        // since it is only an implementation detail, that a new entity is created when
++        // they are traveling between worlds.
++        this.addDuringTeleport(entity, null);
+     }
+ 
+-    public void addDuringCommandTeleport(ServerPlayer serverplayer) {
+-        this.addPlayer(serverplayer);
++    public void addDuringTeleport(Entity entity, CreatureSpawnEvent.SpawnReason reason) {
++        this.addEntity(entity, reason);
++        // CraftBukkit end
+     }
+ 
+-    public void addDuringPortalTeleport(ServerPlayer serverplayer) {
+-        this.addPlayer(serverplayer);
++    public void addDuringCommandTeleport(ServerPlayer player) {
++        this.addPlayer(player);
+     }
+ 
+-    public void addNewPlayer(ServerPlayer serverplayer) {
+-        this.addPlayer(serverplayer);
++    public void addDuringPortalTeleport(ServerPlayer player) {
++        this.addPlayer(player);
+     }
+ 
+-    public void addRespawnedPlayer(ServerPlayer serverplayer) {
+-        this.addPlayer(serverplayer);
++    public void addNewPlayer(ServerPlayer player) {
++        this.addPlayer(player);
+     }
+ 
+-    private void addPlayer(ServerPlayer serverplayer) {
+-        Entity entity = (Entity) this.getEntities().get(serverplayer.getUUID());
++    public void addRespawnedPlayer(ServerPlayer player) {
++        this.addPlayer(player);
++    }
+ 
++    private void addPlayer(ServerPlayer player) {
++        Entity entity = (Entity) this.getEntities().get(player.getUUID());
++
+         if (entity != null) {
+-            ServerLevel.LOGGER.warn("Force-added player with duplicate UUID {}", serverplayer.getUUID());
++            ServerLevel.LOGGER.warn("Force-added player with duplicate UUID {}", player.getUUID());
+             entity.unRide();
+             this.removePlayerImmediately((ServerPlayer) entity, Entity.RemovalReason.DISCARDED);
+         }
+ 
+-        this.entityManager.addNewEntity(serverplayer);
++        this.entityManager.addNewEntity(player);
+     }
+ 
+-    private boolean addEntity(Entity entity) {
++    // CraftBukkit start
++    private boolean addEntity(Entity entity, CreatureSpawnEvent.SpawnReason spawnReason) {
+         if (entity.isRemoved()) {
+-            ServerLevel.LOGGER.warn("Tried to add entity {} but it was marked as removed already", EntityType.getKey(entity.getType()));
++            // WorldServer.LOGGER.warn("Tried to add entity {} but it was marked as removed already", EntityTypes.getKey(entity.getType())); // CraftBukkit
+             return false;
+         } else {
++            // SPIGOT-6415: Don't call spawn event when reason is null. For example when an entity teleports to a new world.
++            if (spawnReason != null && !CraftEventFactory.doEntityAddEventCalling(this, entity, spawnReason)) {
++                return false;
++            }
++            // CraftBukkit end
++
+             return this.entityManager.addNewEntity(entity);
+         }
+     }
+ 
+     public boolean tryAddFreshEntityWithPassengers(Entity entity) {
+-        Stream stream = entity.getSelfAndPassengers().map(Entity::getUUID);
++        // CraftBukkit start
++        return this.tryAddFreshEntityWithPassengers(entity, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.DEFAULT);
++    }
++
++    public boolean tryAddFreshEntityWithPassengers(Entity entity, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason reason) {
++        // CraftBukkit end
++        Stream<UUID> stream = entity.getSelfAndPassengers().map(Entity::getUUID); // CraftBukkit - decompile error
+         PersistentEntitySectionManager persistententitysectionmanager = this.entityManager;
+ 
+         Objects.requireNonNull(this.entityManager);
+         if (stream.anyMatch(persistententitysectionmanager::isLoaded)) {
+             return false;
+         } else {
+-            this.addFreshEntityWithPassengers(entity);
++            this.addFreshEntityWithPassengers(entity, reason); // CraftBukkit
+             return true;
+         }
+     }
+ 
+-    public void unload(LevelChunk levelchunk) {
+-        levelchunk.clearAllBlockEntities();
+-        levelchunk.unregisterTickContainerFromLevel(this);
++    public void unload(LevelChunk chunk) {
++        chunk.clearAllBlockEntities();
++        chunk.unregisterTickContainerFromLevel(this);
+     }
+ 
+-    public void removePlayerImmediately(ServerPlayer serverplayer, Entity.RemovalReason entity_removalreason) {
+-        serverplayer.remove(entity_removalreason);
++    public void removePlayerImmediately(ServerPlayer player, Entity.RemovalReason reason) {
++        player.remove(reason);
+     }
+ 
++    // CraftBukkit start
++    public boolean strikeLightning(Entity entitylightning) {
++        return this.strikeLightning(entitylightning, LightningStrikeEvent.Cause.UNKNOWN);
++    }
++
++    public boolean strikeLightning(Entity entitylightning, LightningStrikeEvent.Cause cause) {
++        LightningStrikeEvent lightning = CraftEventFactory.callLightningStrikeEvent((org.bukkit.entity.LightningStrike) entitylightning.getBukkitEntity(), cause);
++
++        if (lightning.isCancelled()) {
++            return false;
++        }
++
++        return this.addFreshEntity(entitylightning);
++    }
++    // CraftBukkit end
++
+     @Override
+-    @Override
+-    public void destroyBlockProgress(int i, BlockPos blockpos, int j) {
++    public void destroyBlockProgress(int breakerId, BlockPos pos, int progress) {
+         Iterator iterator = this.server.getPlayerList().getPlayers().iterator();
+ 
++        // CraftBukkit start
++        Player entityhuman = null;
++        Entity entity = this.getEntity(breakerId);
++        if (entity instanceof Player) entityhuman = (Player) entity;
++        // CraftBukkit end
++
+         while (iterator.hasNext()) {
+-            ServerPlayer serverplayer = (ServerPlayer) iterator.next();
++            ServerPlayer entityplayer = (ServerPlayer) iterator.next();
+ 
+-            if (serverplayer != null && serverplayer.level() == this && serverplayer.getId() != i) {
+-                double d0 = (double) blockpos.getX() - serverplayer.getX();
+-                double d1 = (double) blockpos.getY() - serverplayer.getY();
+-                double d2 = (double) blockpos.getZ() - serverplayer.getZ();
++            if (entityplayer != null && entityplayer.level() == this && entityplayer.getId() != breakerId) {
++                double d0 = (double) pos.getX() - entityplayer.getX();
++                double d1 = (double) pos.getY() - entityplayer.getY();
++                double d2 = (double) pos.getZ() - entityplayer.getZ();
+ 
++                // CraftBukkit start
++                if (entityhuman != null && !entityplayer.getBukkitEntity().canSee(entityhuman.getBukkitEntity())) {
++                    continue;
++                }
++                // CraftBukkit end
++
+                 if (d0 * d0 + d1 * d1 + d2 * d2 < 1024.0D) {
+-                    serverplayer.connection.send(new ClientboundBlockDestructionPacket(i, blockpos, j));
++                    entityplayer.connection.send(new ClientboundBlockDestructionPacket(breakerId, pos, progress));
+                 }
+             }
+         }
+@@ -995,32 +1154,28 @@
+     }
+ 
+     @Override
+-    @Override
+-    public void playSeededSound(@Nullable Player player, double d0, double d1, double d2, Holder<SoundEvent> holder, SoundSource soundsource, float f, float f1, long i) {
+-        this.server.getPlayerList().broadcast(player, d0, d1, d2, (double) ((SoundEvent) holder.value()).getRange(f), this.dimension(), new ClientboundSoundPacket(holder, soundsource, d0, d1, d2, f, f1, i));
++    public void playSeededSound(@Nullable Player player, double x, double d1, double y, Holder<SoundEvent> holder, SoundSource z, float f, float sound, long source) {
++        this.server.getPlayerList().broadcast(player, x, d1, y, (double) ((SoundEvent) holder.value()).getRange(f), this.dimension(), new ClientboundSoundPacket(holder, z, x, d1, y, f, sound, source));
+     }
+ 
+     @Override
+-    @Override
+-    public void playSeededSound(@Nullable Player player, Entity entity, Holder<SoundEvent> holder, SoundSource soundsource, float f, float f1, long i) {
+-        this.server.getPlayerList().broadcast(player, entity.getX(), entity.getY(), entity.getZ(), (double) ((SoundEvent) holder.value()).getRange(f), this.dimension(), new ClientboundSoundEntityPacket(holder, soundsource, entity, f, f1, i));
++    public void playSeededSound(@Nullable Player player, Entity entity, Holder<SoundEvent> sound, SoundSource category, float volume, float pitch, long seed) {
++        this.server.getPlayerList().broadcast(player, entity.getX(), entity.getY(), entity.getZ(), (double) ((SoundEvent) sound.value()).getRange(volume), this.dimension(), new ClientboundSoundEntityPacket(sound, category, entity, volume, pitch, seed));
+     }
+ 
+     @Override
+-    @Override
+-    public void globalLevelEvent(int i, BlockPos blockpos, int j) {
++    public void globalLevelEvent(int id, BlockPos pos, int data) {
+         if (this.getGameRules().getBoolean(GameRules.RULE_GLOBAL_SOUND_EVENTS)) {
+-            this.server.getPlayerList().broadcastAll(new ClientboundLevelEventPacket(i, blockpos, j, true));
++            this.server.getPlayerList().broadcastAll(new ClientboundLevelEventPacket(id, pos, data, true));
+         } else {
+-            this.levelEvent((Player) null, i, blockpos, j);
++            this.levelEvent((Player) null, id, pos, data);
+         }
+ 
+     }
+ 
+     @Override
+-    @Override
+-    public void levelEvent(@Nullable Player player, int i, BlockPos blockpos, int j) {
+-        this.server.getPlayerList().broadcast(player, (double) blockpos.getX(), (double) blockpos.getY(), (double) blockpos.getZ(), 64.0D, this.dimension(), new ClientboundLevelEventPacket(i, blockpos, j, false));
++    public void levelEvent(@Nullable Player player, int type, BlockPos pos, int data) {
++        this.server.getPlayerList().broadcast(player, (double) pos.getX(), (double) pos.getY(), (double) pos.getZ(), 64.0D, this.dimension(), new ClientboundLevelEventPacket(type, pos, data, false));
+     }
+ 
+     public int getLogicalHeight() {
+@@ -1028,34 +1183,43 @@
+     }
+ 
+     @Override
+-    @Override
+-    public void gameEvent(GameEvent gameevent, Vec3 vec3, GameEvent.Context gameevent_context) {
+-        this.gameEventDispatcher.post(gameevent, vec3, gameevent_context);
++    public void gameEvent(GameEvent event, Vec3 position, GameEvent.Context context) {
++        this.gameEventDispatcher.post(event, position, context);
+     }
+ 
+     @Override
+-    @Override
+-    public void sendBlockUpdated(BlockPos blockpos, BlockState blockstate, BlockState blockstate1, int i) {
++    public void sendBlockUpdated(BlockPos pos, IBlockData oldState, IBlockData newState, int flags) {
+         if (this.isUpdatingNavigations) {
+             String s = "recursive call to sendBlockUpdated";
+ 
+             Util.logAndPauseIfInIde("recursive call to sendBlockUpdated", new IllegalStateException("recursive call to sendBlockUpdated"));
+         }
+ 
+-        this.getChunkSource().blockChanged(blockpos);
+-        VoxelShape voxelshape = blockstate.getCollisionShape(this, blockpos);
+-        VoxelShape voxelshape1 = blockstate1.getCollisionShape(this, blockpos);
++        this.getChunkSource().blockChanged(pos);
++        VoxelShape voxelshape = oldState.getCollisionShape(this, pos);
++        VoxelShape voxelshape1 = newState.getCollisionShape(this, pos);
+ 
+         if (Shapes.joinIsNotEmpty(voxelshape, voxelshape1, BooleanOp.NOT_SAME)) {
+             List<PathNavigation> list = new ObjectArrayList();
+             Iterator iterator = this.navigatingMobs.iterator();
+ 
+             while (iterator.hasNext()) {
+-                Mob mob = (Mob) iterator.next();
+-                PathNavigation pathnavigation = mob.getNavigation();
++                // CraftBukkit start - fix SPIGOT-6362
++                Mob entityinsentient;
++                try {
++                    entityinsentient = (Mob) iterator.next();
++                } catch (java.util.ConcurrentModificationException ex) {
++                    // This can happen because the pathfinder update below may trigger a chunk load, which in turn may cause more navigators to register
++                    // In this case we just run the update again across all the iterators as the chunk will then be loaded
++                    // As this is a relative edge case it is much faster than copying navigators (on either read or write)
++                    sendBlockUpdated(pos, oldState, newState, flags);
++                    return;
++                }
++                // CraftBukkit end
++                PathNavigation navigationabstract = entityinsentient.getNavigation();
+ 
+-                if (pathnavigation.shouldRecomputePath(blockpos)) {
+-                    list.add(pathnavigation);
++                if (navigationabstract.shouldRecomputePath(pos)) {
++                    list.add(navigationabstract);
+                 }
+             }
+ 
+@@ -1064,9 +1228,9 @@
+                 iterator = list.iterator();
+ 
+                 while (iterator.hasNext()) {
+-                    PathNavigation pathnavigation1 = (PathNavigation) iterator.next();
++                    PathNavigation navigationabstract1 = (PathNavigation) iterator.next();
+ 
+-                    pathnavigation1.recomputePath();
++                    navigationabstract1.recomputePath();
+                 }
+             } finally {
+                 this.isUpdatingNavigations = false;
+@@ -1076,51 +1240,48 @@
+     }
+ 
+     @Override
+-    @Override
+-    public void updateNeighborsAt(BlockPos blockpos, Block block) {
+-        this.neighborUpdater.updateNeighborsAtExceptFromFacing(blockpos, block, (Direction) null);
++    public void updateNeighborsAt(BlockPos pos, Block block) {
++        this.neighborUpdater.updateNeighborsAtExceptFromFacing(pos, block, (Direction) null);
+     }
+ 
+     @Override
+-    @Override
+-    public void updateNeighborsAtExceptFromFacing(BlockPos blockpos, Block block, Direction direction) {
+-        this.neighborUpdater.updateNeighborsAtExceptFromFacing(blockpos, block, direction);
++    public void updateNeighborsAtExceptFromFacing(BlockPos pos, Block blockType, Direction skipSide) {
++        this.neighborUpdater.updateNeighborsAtExceptFromFacing(pos, blockType, skipSide);
+     }
+ 
+     @Override
+-    @Override
+-    public void neighborChanged(BlockPos blockpos, Block block, BlockPos blockpos1) {
+-        this.neighborUpdater.neighborChanged(blockpos, block, blockpos1);
++    public void neighborChanged(BlockPos pos, Block block, BlockPos fromPos) {
++        this.neighborUpdater.neighborChanged(pos, block, fromPos);
+     }
+ 
+     @Override
+-    @Override
+-    public void neighborChanged(BlockState blockstate, BlockPos blockpos, Block block, BlockPos blockpos1, boolean flag) {
+-        this.neighborUpdater.neighborChanged(blockstate, blockpos, block, blockpos1, flag);
++    public void neighborChanged(IBlockData state, BlockPos pos, Block block, BlockPos fromPos, boolean isMoving) {
++        this.neighborUpdater.neighborChanged(state, pos, block, fromPos, isMoving);
+     }
+ 
+     @Override
+-    @Override
+-    public void broadcastEntityEvent(Entity entity, byte b0) {
+-        this.getChunkSource().broadcastAndSend(entity, new ClientboundEntityEventPacket(entity, b0));
++    public void broadcastEntityEvent(Entity entity, byte state) {
++        this.getChunkSource().broadcastAndSend(entity, new ClientboundEntityEventPacket(entity, state));
+     }
+ 
+     @Override
+-    @Override
+-    public void broadcastDamageEvent(Entity entity, DamageSource damagesource) {
+-        this.getChunkSource().broadcastAndSend(entity, new ClientboundDamageEventPacket(entity, damagesource));
++    public void broadcastDamageEvent(Entity entity, DamageSource damageSource) {
++        this.getChunkSource().broadcastAndSend(entity, new ClientboundDamageEventPacket(entity, damageSource));
+     }
+ 
+     @Override
+-    @Override
+     public ServerChunkCache getChunkSource() {
+         return this.chunkSource;
+     }
+ 
+     @Override
+-    @Override
+-    public Explosion explode(@Nullable Entity entity, @Nullable DamageSource damagesource, @Nullable ExplosionDamageCalculator explosiondamagecalculator, double d0, double d1, double d2, float f, boolean flag, Level.ExplosionInteraction level_explosioninteraction, ParticleOptions particleoptions, ParticleOptions particleoptions1, SoundEvent soundevent) {
+-        Explosion explosion = this.explode(entity, damagesource, explosiondamagecalculator, d0, d1, d2, f, flag, level_explosioninteraction, false, particleoptions, particleoptions1, soundevent);
++    public Explosion explode(@Nullable Entity entity, @Nullable DamageSource damagesource, @Nullable ExplosionDamageCalculator explosiondamagecalculator, double d0, double d1, double d2, float f, boolean flag, Level.a world_a, ParticleOptions particleparam, ParticleOptions particleparam1, SoundEvent soundeffect) {
++        Explosion explosion = this.explode(entity, damagesource, explosiondamagecalculator, d0, d1, d2, f, flag, world_a, false, particleparam, particleparam1, soundeffect);
++        // CraftBukkit start
++        if (explosion.wasCanceled) {
++            return explosion;
++        }
++        // CraftBukkit end
+ 
+         if (!explosion.interactsWithBlocks()) {
+             explosion.clearToBlow();
+@@ -1129,10 +1290,10 @@
+         Iterator iterator = this.players.iterator();
+ 
+         while (iterator.hasNext()) {
+-            ServerPlayer serverplayer = (ServerPlayer) iterator.next();
++            ServerPlayer entityplayer = (ServerPlayer) iterator.next();
+ 
+-            if (serverplayer.distanceToSqr(d0, d1, d2) < 4096.0D) {
+-                serverplayer.connection.send(new ClientboundExplodePacket(d0, d1, d2, f, explosion.getToBlow(), (Vec3) explosion.getHitPlayers().get(serverplayer), explosion.getBlockInteraction(), explosion.getSmallExplosionParticles(), explosion.getLargeExplosionParticles(), explosion.getExplosionSound()));
++            if (entityplayer.distanceToSqr(d0, d1, d2) < 4096.0D) {
++                entityplayer.connection.send(new ClientboundExplodePacket(d0, d1, d2, f, explosion.getToBlow(), (Vec3) explosion.getHitPlayers().get(entityplayer), explosion.getBlockInteraction(), explosion.getSmallExplosionParticles(), explosion.getLargeExplosionParticles(), explosion.getExplosionSound()));
+             }
+         }
+ 
+@@ -1140,50 +1301,46 @@
+     }
+ 
+     @Override
+-    @Override
+-    public void blockEvent(BlockPos blockpos, Block block, int i, int j) {
+-        this.blockEvents.add(new BlockEventData(blockpos, block, i, j));
++    public void blockEvent(BlockPos pos, Block block, int eventID, int eventParam) {
++        this.blockEvents.add(new BlockEventData(pos, block, eventID, eventParam));
+     }
+ 
+     private void runBlockEvents() {
+         this.blockEventsToReschedule.clear();
+ 
+         while (!this.blockEvents.isEmpty()) {
+-            BlockEventData blockeventdata = (BlockEventData) this.blockEvents.removeFirst();
++            BlockEventData blockactiondata = (BlockEventData) this.blockEvents.removeFirst();
+ 
+-            if (this.shouldTickBlocksAt(blockeventdata.pos())) {
+-                if (this.doBlockEvent(blockeventdata)) {
+-                    this.server.getPlayerList().broadcast((Player) null, (double) blockeventdata.pos().getX(), (double) blockeventdata.pos().getY(), (double) blockeventdata.pos().getZ(), 64.0D, this.dimension(), new ClientboundBlockEventPacket(blockeventdata.pos(), blockeventdata.block(), blockeventdata.paramA(), blockeventdata.paramB()));
++            if (this.shouldTickBlocksAt(blockactiondata.pos())) {
++                if (this.doBlockEvent(blockactiondata)) {
++                    this.server.getPlayerList().broadcast((Player) null, (double) blockactiondata.pos().getX(), (double) blockactiondata.pos().getY(), (double) blockactiondata.pos().getZ(), 64.0D, this.dimension(), new ClientboundBlockEventPacket(blockactiondata.pos(), blockactiondata.block(), blockactiondata.paramA(), blockactiondata.paramB()));
+                 }
+             } else {
+-                this.blockEventsToReschedule.add(blockeventdata);
++                this.blockEventsToReschedule.add(blockactiondata);
+             }
+         }
+ 
+         this.blockEvents.addAll(this.blockEventsToReschedule);
+     }
+ 
+-    private boolean doBlockEvent(BlockEventData blockeventdata) {
+-        BlockState blockstate = this.getBlockState(blockeventdata.pos());
++    private boolean doBlockEvent(BlockEventData event) {
++        IBlockData iblockdata = this.getBlockState(event.pos());
+ 
+-        return blockstate.is(blockeventdata.block()) ? blockstate.triggerEvent(this, blockeventdata.pos(), blockeventdata.paramA(), blockeventdata.paramB()) : false;
++        return iblockdata.is(event.block()) ? iblockdata.triggerEvent(this, event.pos(), event.paramA(), event.paramB()) : false;
+     }
+ 
+     @Override
+-    @Override
+     public LevelTicks<Block> getBlockTicks() {
+         return this.blockTicks;
+     }
+ 
+     @Override
+-    @Override
+     public LevelTicks<Fluid> getFluidTicks() {
+         return this.fluidTicks;
+     }
+ 
+     @Nonnull
+     @Override
+-    @Override
+     public MinecraftServer getServer() {
+         return this.server;
+     }
+@@ -1196,14 +1353,21 @@
+         return this.server.getStructureManager();
+     }
+ 
+-    public <T extends ParticleOptions> int sendParticles(T t0, double d0, double d1, double d2, int i, double d3, double d4, double d5, double d6) {
+-        ClientboundLevelParticlesPacket clientboundlevelparticlespacket = new ClientboundLevelParticlesPacket(t0, false, d0, d1, d2, (float) d3, (float) d4, (float) d5, (float) d6, i);
++    public <T extends ParticleOptions> int sendParticles(T type, double posX, double d1, double posY, int i, double posZ, double d4, double particleCount, double xOffset) {
++        // CraftBukkit - visibility api support
++        return sendParticles(null, type, posX, d1, posY, i, posZ, d4, particleCount, xOffset, false);
++    }
++
++    public <T extends ParticleOptions> int sendParticles(ServerPlayer sender, T t0, double d0, double d1, double d2, int i, double d3, double d4, double d5, double d6, boolean force) {
++        ClientboundLevelParticlesPacket packetplayoutworldparticles = new ClientboundLevelParticlesPacket(t0, force, d0, d1, d2, (float) d3, (float) d4, (float) d5, (float) d6, i);
++        // CraftBukkit end
+         int j = 0;
+ 
+         for (int k = 0; k < this.players.size(); ++k) {
+-            ServerPlayer serverplayer = (ServerPlayer) this.players.get(k);
++            ServerPlayer entityplayer = (ServerPlayer) this.players.get(k);
++            if (sender != null && !entityplayer.getBukkitEntity().canSee(sender.getBukkitEntity())) continue; // CraftBukkit
+ 
+-            if (this.sendParticles(serverplayer, false, d0, d1, d2, clientboundlevelparticlespacket)) {
++            if (this.sendParticles(entityplayer, force, d0, d1, d2, packetplayoutworldparticles)) { // CraftBukkit
+                 ++j;
+             }
+         }
+@@ -1211,20 +1375,20 @@
+         return j;
+     }
+ 
+-    public <T extends ParticleOptions> boolean sendParticles(ServerPlayer serverplayer, T t0, boolean flag, double d0, double d1, double d2, int i, double d3, double d4, double d5, double d6) {
+-        Packet<?> packet = new ClientboundLevelParticlesPacket(t0, flag, d0, d1, d2, (float) d3, (float) d4, (float) d5, (float) d6, i);
++    public <T extends ParticleOptions> boolean sendParticles(ServerPlayer player, T type, boolean longDistance, double posX, double d1, double posY, int i, double posZ, double d4, double particleCount, double xOffset) {
++        Packet<?> packet = new ClientboundLevelParticlesPacket(type, longDistance, posX, d1, posY, (float) posZ, (float) d4, (float) particleCount, (float) xOffset, i);
+ 
+-        return this.sendParticles(serverplayer, flag, d0, d1, d2, packet);
++        return this.sendParticles(player, longDistance, posX, d1, posY, packet);
+     }
+ 
+-    private boolean sendParticles(ServerPlayer serverplayer, boolean flag, double d0, double d1, double d2, Packet<?> packet) {
+-        if (serverplayer.level() != this) {
++    private boolean sendParticles(ServerPlayer player, boolean longDistance, double posX, double d1, double posY, Packet<?> packet) {
++        if (player.level() != this) {
+             return false;
+         } else {
+-            BlockPos blockpos = serverplayer.blockPosition();
++            BlockPos blockposition = player.blockPosition();
+ 
+-            if (blockpos.closerToCenterThan(new Vec3(d0, d1, d2), flag ? 512.0D : 32.0D)) {
+-                serverplayer.connection.send(packet);
++            if (blockposition.closerToCenterThan(new Vec3(posX, d1, posY), longDistance ? 512.0D : 32.0D)) {
++                player.connection.send(packet);
+                 return true;
+             } else {
+                 return false;
+@@ -1234,36 +1398,35 @@
+ 
+     @Nullable
+     @Override
+-    @Override
+-    public Entity getEntity(int i) {
+-        return (Entity) this.getEntities().get(i);
++    public Entity getEntity(int id) {
++        return (Entity) this.getEntities().get(id);
+     }
+ 
+     /** @deprecated */
+     @Deprecated
+     @Nullable
+-    public Entity getEntityOrPart(int i) {
+-        Entity entity = (Entity) this.getEntities().get(i);
++    public Entity getEntityOrPart(int id) {
++        Entity entity = (Entity) this.getEntities().get(id);
+ 
+-        return entity != null ? entity : (Entity) this.dragonParts.get(i);
++        return entity != null ? entity : (Entity) this.dragonParts.get(id);
+     }
+ 
+     @Nullable
+-    public Entity getEntity(UUID uuid) {
+-        return (Entity) this.getEntities().get(uuid);
++    public Entity getEntity(UUID uniqueId) {
++        return (Entity) this.getEntities().get(uniqueId);
+     }
+ 
+     @Nullable
+-    public BlockPos findNearestMapStructure(TagKey<Structure> tagkey, BlockPos blockpos, int i, boolean flag) {
+-        if (!this.server.getWorldData().worldGenOptions().generateStructures()) {
++    public BlockPos findNearestMapStructure(TagKey<Structure> structureTag, BlockPos pos, int radius, boolean skipExistingChunks) {
++        if (!this.serverLevelData.worldGenOptions().generateStructures()) { // CraftBukkit
+             return null;
+         } else {
+-            Optional<HolderSet.Named<Structure>> optional = this.registryAccess().registryOrThrow(Registries.STRUCTURE).getTag(tagkey);
++            Optional<HolderSet.Named<Structure>> optional = this.registryAccess().registryOrThrow(Registries.STRUCTURE).getTag(structureTag);
+ 
+             if (optional.isEmpty()) {
+                 return null;
+             } else {
+-                Pair<BlockPos, Holder<Structure>> pair = this.getChunkSource().getGenerator().findNearestMapStructure(this, (HolderSet) optional.get(), blockpos, i, flag);
++                Pair<BlockPos, Holder<Structure>> pair = this.getChunkSource().getGenerator().findNearestMapStructure(this, (HolderSet) optional.get(), pos, radius, skipExistingChunks);
+ 
+                 return pair != null ? (BlockPos) pair.getFirst() : null;
+             }
+@@ -1271,24 +1434,21 @@
+     }
+ 
+     @Nullable
+-    public Pair<BlockPos, Holder<Biome>> findClosestBiome3d(Predicate<Holder<Biome>> predicate, BlockPos blockpos, int i, int j, int k) {
+-        return this.getChunkSource().getGenerator().getBiomeSource().findClosestBiome3d(blockpos, i, j, k, predicate, this.getChunkSource().randomState().sampler(), this);
++    public Pair<BlockPos, Holder<Biome>> findClosestBiome3d(Predicate<Holder<Biome>> biomePredicate, BlockPos pos, int i, int j, int k) {
++        return this.getChunkSource().getGenerator().getBiomeSource().findClosestBiome3d(pos, i, j, k, biomePredicate, this.getChunkSource().randomState().sampler(), this);
+     }
+ 
+     @Override
+-    @Override
+     public RecipeManager getRecipeManager() {
+         return this.server.getRecipeManager();
+     }
+ 
+     @Override
+-    @Override
+     public TickRateManager tickRateManager() {
+         return this.server.tickRateManager();
+     }
+ 
+     @Override
+-    @Override
+     public boolean noSave() {
+         return this.noSave;
+     }
+@@ -1299,86 +1459,92 @@
+ 
+     @Nullable
+     @Override
+-    @Override
+-    public MapItemSavedData getMapData(String s) {
+-        return (MapItemSavedData) this.getServer().overworld().getDataStorage().get(MapItemSavedData.factory(), s);
++    public MapItemSavedData getMapData(String mapName) {
++        // CraftBukkit start
++        MapItemSavedData worldmap = (MapItemSavedData) this.getServer().overworld().getDataStorage().get(MapItemSavedData.factory(), mapName);
++        if (worldmap != null) {
++            worldmap.id = mapName;
++        }
++        return worldmap;
++        // CraftBukkit end
+     }
+ 
+     @Override
+-    @Override
+-    public void setMapData(String s, MapItemSavedData mapitemsaveddata) {
+-        this.getServer().overworld().getDataStorage().set(s, mapitemsaveddata);
++    public void setMapData(String mapName, MapItemSavedData data) {
++        // CraftBukkit start
++        data.id = mapName;
++        MapInitializeEvent event = new MapInitializeEvent(data.mapView);
++        Bukkit.getServer().getPluginManager().callEvent(event);
++        // CraftBukkit end
++        this.getServer().overworld().getDataStorage().set(mapName, data);
+     }
+ 
+     @Override
+-    @Override
+     public int getFreeMapId() {
+         return ((MapIndex) this.getServer().overworld().getDataStorage().computeIfAbsent(MapIndex.factory(), "idcounts")).getFreeAuxValueForMap();
+     }
+ 
+-    public void setDefaultSpawnPos(BlockPos blockpos, float f) {
+-        ChunkPos chunkpos = new ChunkPos(new BlockPos(this.levelData.getXSpawn(), 0, this.levelData.getZSpawn()));
++    public void setDefaultSpawnPos(BlockPos pos, float angle) {
++        ChunkPos chunkcoordintpair = new ChunkPos(new BlockPos(this.levelData.getXSpawn(), 0, this.levelData.getZSpawn()));
+ 
+-        this.levelData.setSpawn(blockpos, f);
+-        this.getChunkSource().removeRegionTicket(TicketType.START, chunkpos, 11, Unit.INSTANCE);
+-        this.getChunkSource().addRegionTicket(TicketType.START, new ChunkPos(blockpos), 11, Unit.INSTANCE);
+-        this.getServer().getPlayerList().broadcastAll(new ClientboundSetDefaultSpawnPositionPacket(blockpos, f));
++        this.levelData.setSpawn(pos, angle);
++        this.getChunkSource().removeRegionTicket(TicketType.START, chunkcoordintpair, 11, Unit.INSTANCE);
++        this.getChunkSource().addRegionTicket(TicketType.START, new ChunkPos(pos), 11, Unit.INSTANCE);
++        this.getServer().getPlayerList().broadcastAll(new ClientboundSetDefaultSpawnPositionPacket(pos, angle));
+     }
+ 
+     public LongSet getForcedChunks() {
+-        ForcedChunksSavedData forcedchunkssaveddata = (ForcedChunksSavedData) this.getDataStorage().get(ForcedChunksSavedData.factory(), "chunks");
++        ForcedChunksSavedData forcedchunk = (ForcedChunksSavedData) this.getDataStorage().get(ForcedChunksSavedData.factory(), "chunks");
+ 
+-        return (LongSet) (forcedchunkssaveddata != null ? LongSets.unmodifiable(forcedchunkssaveddata.getChunks()) : LongSets.EMPTY_SET);
++        return (LongSet) (forcedchunk != null ? LongSets.unmodifiable(forcedchunk.getChunks()) : LongSets.EMPTY_SET);
+     }
+ 
+-    public boolean setChunkForced(int i, int j, boolean flag) {
+-        ForcedChunksSavedData forcedchunkssaveddata = (ForcedChunksSavedData) this.getDataStorage().computeIfAbsent(ForcedChunksSavedData.factory(), "chunks");
+-        ChunkPos chunkpos = new ChunkPos(i, j);
+-        long k = chunkpos.toLong();
++    public boolean setChunkForced(int chunkX, int chunkZ, boolean add) {
++        ForcedChunksSavedData forcedchunk = (ForcedChunksSavedData) this.getDataStorage().computeIfAbsent(ForcedChunksSavedData.factory(), "chunks");
++        ChunkPos chunkcoordintpair = new ChunkPos(chunkX, chunkZ);
++        long k = chunkcoordintpair.toLong();
+         boolean flag1;
+ 
+-        if (flag) {
+-            flag1 = forcedchunkssaveddata.getChunks().add(k);
++        if (add) {
++            flag1 = forcedchunk.getChunks().add(k);
+             if (flag1) {
+-                this.getChunk(i, j);
++                this.getChunk(chunkX, chunkZ);
+             }
+         } else {
+-            flag1 = forcedchunkssaveddata.getChunks().remove(k);
++            flag1 = forcedchunk.getChunks().remove(k);
+         }
+ 
+-        forcedchunkssaveddata.setDirty(flag1);
++        forcedchunk.setDirty(flag1);
+         if (flag1) {
+-            this.getChunkSource().updateChunkForced(chunkpos, flag);
++            this.getChunkSource().updateChunkForced(chunkcoordintpair, add);
+         }
+ 
+         return flag1;
+     }
+ 
+     @Override
+-    @Override
+     public List<ServerPlayer> players() {
+         return this.players;
+     }
+ 
+     @Override
+-    @Override
+-    public void onBlockStateChange(BlockPos blockpos, BlockState blockstate, BlockState blockstate1) {
+-        Optional<Holder<PoiType>> optional = PoiTypes.forState(blockstate);
+-        Optional<Holder<PoiType>> optional1 = PoiTypes.forState(blockstate1);
++    public void onBlockStateChange(BlockPos pos, IBlockData blockState, IBlockData newState) {
++        Optional<Holder<PoiType>> optional = PoiTypes.forState(blockState);
++        Optional<Holder<PoiType>> optional1 = PoiTypes.forState(newState);
+ 
+         if (!Objects.equals(optional, optional1)) {
+-            BlockPos blockpos1 = blockpos.immutable();
++            BlockPos blockposition1 = pos.immutable();
+ 
+             optional.ifPresent((holder) -> {
+                 this.getServer().execute(() -> {
+-                    this.getPoiManager().remove(blockpos1);
+-                    DebugPackets.sendPoiRemovedPacket(this, blockpos1);
++                    this.getPoiManager().remove(blockposition1);
++                    DebugPackets.sendPoiRemovedPacket(this, blockposition1);
+                 });
+             });
+             optional1.ifPresent((holder) -> {
+                 this.getServer().execute(() -> {
+-                    this.getPoiManager().add(blockpos1, holder);
+-                    DebugPackets.sendPoiAddedPacket(this, blockpos1);
++                    this.getPoiManager().add(blockposition1, holder);
++                    DebugPackets.sendPoiAddedPacket(this, blockposition1);
+                 });
+             });
+         }
+@@ -1388,20 +1554,20 @@
+         return this.getChunkSource().getPoiManager();
+     }
+ 
+-    public boolean isVillage(BlockPos blockpos) {
+-        return this.isCloseToVillage(blockpos, 1);
++    public boolean isVillage(BlockPos pos) {
++        return this.isCloseToVillage(pos, 1);
+     }
+ 
+-    public boolean isVillage(SectionPos sectionpos) {
+-        return this.isVillage(sectionpos.center());
++    public boolean isVillage(SectionPos pos) {
++        return this.isVillage(pos.center());
+     }
+ 
+-    public boolean isCloseToVillage(BlockPos blockpos, int i) {
+-        return i > 6 ? false : this.sectionsToVillage(SectionPos.of(blockpos)) <= i;
++    public boolean isCloseToVillage(BlockPos pos, int sections) {
++        return sections > 6 ? false : this.sectionsToVillage(SectionPos.of(pos)) <= sections;
+     }
+ 
+-    public int sectionsToVillage(SectionPos sectionpos) {
+-        return this.getPoiManager().sectionsToVillage(sectionpos);
++    public int sectionsToVillage(SectionPos pos) {
++        return this.getPoiManager().sectionsToVillage(pos);
+     }
+ 
+     public Raids getRaids() {
+@@ -1409,28 +1575,28 @@
+     }
+ 
+     @Nullable
+-    public Raid getRaidAt(BlockPos blockpos) {
+-        return this.raids.getNearbyRaid(blockpos, 9216);
++    public Raid getRaidAt(BlockPos pos) {
++        return this.raids.getNearbyRaid(pos, 9216);
+     }
+ 
+-    public boolean isRaided(BlockPos blockpos) {
+-        return this.getRaidAt(blockpos) != null;
++    public boolean isRaided(BlockPos pos) {
++        return this.getRaidAt(pos) != null;
+     }
+ 
+-    public void onReputationEvent(ReputationEventType reputationeventtype, Entity entity, ReputationEventHandler reputationeventhandler) {
+-        reputationeventhandler.onReputationEventFrom(reputationeventtype, entity);
++    public void onReputationEvent(ReputationEventType type, Entity target, ReputationEventHandler host) {
++        host.onReputationEventFrom(type, target);
+     }
+ 
+     public void saveDebugReport(Path path) throws IOException {
+-        ChunkMap chunkmap = this.getChunkSource().chunkMap;
++        ChunkMap playerchunkmap = this.getChunkSource().chunkMap;
+         BufferedWriter bufferedwriter = Files.newBufferedWriter(path.resolve("stats.txt"));
+ 
+         try {
+-            bufferedwriter.write(String.format(Locale.ROOT, "spawning_chunks: %d\n", chunkmap.getDistanceManager().getNaturalSpawnChunkCount()));
+-            NaturalSpawner.SpawnState naturalspawner_spawnstate = this.getChunkSource().getLastSpawnState();
++            bufferedwriter.write(String.format(Locale.ROOT, "spawning_chunks: %d\n", playerchunkmap.getDistanceManager().getNaturalSpawnChunkCount()));
++            NaturalSpawner.SpawnState spawnercreature_d = this.getChunkSource().getLastSpawnState();
+ 
+-            if (naturalspawner_spawnstate != null) {
+-                ObjectIterator objectiterator = naturalspawner_spawnstate.getMobCategoryCounts().object2IntEntrySet().iterator();
++            if (spawnercreature_d != null) {
++                ObjectIterator objectiterator = spawnercreature_d.getMobCategoryCounts().object2IntEntrySet().iterator();
+ 
+                 while (objectiterator.hasNext()) {
+                     Entry<MobCategory> entry = (Entry) objectiterator.next();
+@@ -1443,7 +1609,7 @@
+             bufferedwriter.write(String.format(Locale.ROOT, "block_entity_tickers: %d\n", this.blockEntityTickers.size()));
+             bufferedwriter.write(String.format(Locale.ROOT, "block_ticks: %d\n", this.getBlockTicks().count()));
+             bufferedwriter.write(String.format(Locale.ROOT, "fluid_ticks: %d\n", this.getFluidTicks().count()));
+-            bufferedwriter.write("distance_manager: " + chunkmap.getDistanceManager().getDebugStatus() + "\n");
++            bufferedwriter.write("distance_manager: " + playerchunkmap.getDistanceManager().getDebugStatus() + "\n");
+             bufferedwriter.write(String.format(Locale.ROOT, "pending_tasks: %d\n", this.getChunkSource().getPendingTasksCount()));
+         } catch (Throwable throwable) {
+             if (bufferedwriter != null) {
+@@ -1488,7 +1654,7 @@
+         BufferedWriter bufferedwriter2 = Files.newBufferedWriter(path1);
+ 
+         try {
+-            chunkmap.dumpChunks(bufferedwriter2);
++            playerchunkmap.dumpChunks(bufferedwriter2);
+         } catch (Throwable throwable4) {
+             if (bufferedwriter2 != null) {
+                 try {
+@@ -1570,52 +1736,55 @@
+ 
+     }
+ 
+-    private static void dumpEntities(Writer writer, Iterable<Entity> iterable) throws IOException {
+-        CsvOutput csvoutput = CsvOutput.builder().addColumn("x").addColumn("y").addColumn("z").addColumn("uuid").addColumn("type").addColumn("alive").addColumn("display_name").addColumn("custom_name").build(writer);
+-        Iterator iterator = iterable.iterator();
++    private static void dumpEntities(Writer writer, Iterable<Entity> entities) throws IOException {
++        CsvOutput csvwriter = CsvOutput.builder().addColumn("x").addColumn("y").addColumn("z").addColumn("uuid").addColumn("type").addColumn("alive").addColumn("display_name").addColumn("custom_name").build(writer);
++        Iterator iterator = entities.iterator();
+ 
+         while (iterator.hasNext()) {
+             Entity entity = (Entity) iterator.next();
+-            Component component = entity.getCustomName();
+-            Component component1 = entity.getDisplayName();
++            Component ichatbasecomponent = entity.getCustomName();
++            Component ichatbasecomponent1 = entity.getDisplayName();
+ 
+-            csvoutput.writeRow(entity.getX(), entity.getY(), entity.getZ(), entity.getUUID(), BuiltInRegistries.ENTITY_TYPE.getKey(entity.getType()), entity.isAlive(), component1.getString(), component != null ? component.getString() : null);
++            csvwriter.writeRow(entity.getX(), entity.getY(), entity.getZ(), entity.getUUID(), BuiltInRegistries.ENTITY_TYPE.getKey(entity.getType()), entity.isAlive(), ichatbasecomponent1.getString(), ichatbasecomponent != null ? ichatbasecomponent.getString() : null);
+         }
+ 
+     }
+ 
+-    private void dumpBlockEntityTickers(Writer writer) throws IOException {
+-        CsvOutput csvoutput = CsvOutput.builder().addColumn("x").addColumn("y").addColumn("z").addColumn("type").build(writer);
++    private void dumpBlockEntityTickers(Writer output) throws IOException {
++        CsvOutput csvwriter = CsvOutput.builder().addColumn("x").addColumn("y").addColumn("z").addColumn("type").build(output);
+         Iterator iterator = this.blockEntityTickers.iterator();
+ 
+         while (iterator.hasNext()) {
+             TickingBlockEntity tickingblockentity = (TickingBlockEntity) iterator.next();
+-            BlockPos blockpos = tickingblockentity.getPos();
++            BlockPos blockposition = tickingblockentity.getPos();
+ 
+-            csvoutput.writeRow(blockpos.getX(), blockpos.getY(), blockpos.getZ(), tickingblockentity.getType());
++            csvwriter.writeRow(blockposition.getX(), blockposition.getY(), blockposition.getZ(), tickingblockentity.getType());
+         }
+ 
+     }
+ 
+     @VisibleForTesting
+-    public void clearBlockEvents(BoundingBox boundingbox) {
+-        this.blockEvents.removeIf((blockeventdata) -> {
+-            return boundingbox.isInside(blockeventdata.pos());
++    public void clearBlockEvents(BoundingBox boundingBox) {
++        this.blockEvents.removeIf((blockactiondata) -> {
++            return boundingBox.isInside(blockactiondata.pos());
+         });
+     }
+ 
+     @Override
+-    @Override
+-    public void blockUpdated(BlockPos blockpos, Block block) {
++    public void blockUpdated(BlockPos pos, Block block) {
+         if (!this.isDebug()) {
+-            this.updateNeighborsAt(blockpos, block);
++            // CraftBukkit start
++            if (populating) {
++                return;
++            }
++            // CraftBukkit end
++            this.updateNeighborsAt(pos, block);
+         }
+ 
+     }
+ 
+     @Override
+-    @Override
+-    public float getShade(Direction direction, boolean flag) {
++    public float getShade(Direction direction, boolean shade) {
+         return 1.0F;
+     }
+ 
+@@ -1623,19 +1792,17 @@
+         return this.getEntities().getAll();
+     }
+ 
+-    @Override
+     public String toString() {
+         return "ServerLevel[" + this.serverLevelData.getLevelName() + "]";
+     }
+ 
+     public boolean isFlat() {
+-        return this.server.getWorldData().isFlatWorld();
++        return this.serverLevelData.isFlatWorld(); // CraftBukkit
+     }
+ 
+     @Override
+-    @Override
+     public long getSeed() {
+-        return this.server.getWorldData().worldGenOptions().seed();
++        return this.serverLevelData.worldGenOptions().seed(); // CraftBukkit
+     }
+ 
+     @Nullable
+@@ -1644,7 +1811,6 @@
+     }
+ 
+     @Override
+-    @Override
+     public ServerLevel getLevel() {
+         return this;
+     }
+@@ -1656,19 +1822,19 @@
+         }), this.blockEntityTickers.size(), getTypeCount(this.blockEntityTickers, TickingBlockEntity::getType), this.getBlockTicks().count(), this.getFluidTicks().count(), this.gatherChunkSourceStats());
+     }
+ 
+-    private static <T> String getTypeCount(Iterable<T> iterable, Function<T, String> function) {
++    private static <T> String getTypeCount(Iterable<T> objects, Function<T, String> typeGetter) {
+         try {
+             Object2IntOpenHashMap<String> object2intopenhashmap = new Object2IntOpenHashMap();
+-            Iterator iterator = iterable.iterator();
++            Iterator<T> iterator = objects.iterator(); // CraftBukkit - decompile error
+ 
+             while (iterator.hasNext()) {
+                 T t0 = iterator.next();
+-                String s = (String) function.apply(t0);
++                String s = (String) typeGetter.apply(t0);
+ 
+                 object2intopenhashmap.addTo(s, 1);
+             }
+ 
+-            return (String) object2intopenhashmap.object2IntEntrySet().stream().sorted(Comparator.comparing(Entry::getIntValue).reversed()).limit(5L).map((entry) -> {
++            return (String) object2intopenhashmap.object2IntEntrySet().stream().sorted(Comparator.comparing(Entry<String>::getIntValue).reversed()).limit(5L).map((entry) -> { // CraftBukkit - decompile error
+                 String s1 = (String) entry.getKey();
+ 
+                 return s1 + ":" + entry.getIntValue();
+@@ -1678,87 +1844,99 @@
+         }
+     }
+ 
+-    public static void makeObsidianPlatform(ServerLevel serverlevel) {
+-        BlockPos blockpos = ServerLevel.END_SPAWN_POINT;
+-        int i = blockpos.getX();
+-        int j = blockpos.getY() - 2;
+-        int k = blockpos.getZ();
++    public static void makeObsidianPlatform(ServerLevel serverLevel) {
++        // CraftBukkit start
++        ServerLevel.makeObsidianPlatform(serverLevel, null);
++    }
+ 
+-        BlockPos.betweenClosed(i - 2, j + 1, k - 2, i + 2, j + 3, k + 2).forEach((blockpos1) -> {
+-            serverlevel.setBlockAndUpdate(blockpos1, Blocks.AIR.defaultBlockState());
++    public static void makeObsidianPlatform(ServerLevel worldserver, Entity entity) {
++        // CraftBukkit end
++        BlockPos blockposition = ServerLevel.END_SPAWN_POINT;
++        int i = blockposition.getX();
++        int j = blockposition.getY() - 2;
++        int k = blockposition.getZ();
++
++        // CraftBukkit start
++        org.bukkit.craftbukkit.util.BlockStateListPopulator blockList = new org.bukkit.craftbukkit.util.BlockStateListPopulator(worldserver);
++        BlockPos.betweenClosed(i - 2, j + 1, k - 2, i + 2, j + 3, k + 2).forEach((blockposition1) -> {
++            blockList.setBlock(blockposition1, Blocks.AIR.defaultBlockState(), 3);
+         });
+-        BlockPos.betweenClosed(i - 2, j, k - 2, i + 2, j, k + 2).forEach((blockpos1) -> {
+-            serverlevel.setBlockAndUpdate(blockpos1, Blocks.OBSIDIAN.defaultBlockState());
++        BlockPos.betweenClosed(i - 2, j, k - 2, i + 2, j, k + 2).forEach((blockposition1) -> {
++            blockList.setBlock(blockposition1, Blocks.OBSIDIAN.defaultBlockState(), 3);
+         });
++        org.bukkit.World bworld = worldserver.getWorld();
++        org.bukkit.event.world.PortalCreateEvent portalEvent = new org.bukkit.event.world.PortalCreateEvent((List<org.bukkit.block.BlockState>) (List) blockList.getList(), bworld, (entity == null) ? null : entity.getBukkitEntity(), org.bukkit.event.world.PortalCreateEvent.CreateReason.END_PLATFORM);
++
++        worldserver.getCraftServer().getPluginManager().callEvent(portalEvent);
++        if (!portalEvent.isCancelled()) {
++            blockList.updateList();
++        }
++        // CraftBukkit end
+     }
+ 
+     @Override
+-    @Override
+-    protected LevelEntityGetter<Entity> getEntities() {
++    public LevelEntityGetter<Entity> getEntities() {
+         return this.entityManager.getEntityGetter();
+     }
+ 
+-    public void addLegacyChunkEntities(Stream<Entity> stream) {
+-        this.entityManager.addLegacyChunkEntities(stream);
++    public void addLegacyChunkEntities(Stream<Entity> entities) {
++        this.entityManager.addLegacyChunkEntities(entities);
+     }
+ 
+-    public void addWorldGenChunkEntities(Stream<Entity> stream) {
+-        this.entityManager.addWorldGenChunkEntities(stream);
++    public void addWorldGenChunkEntities(Stream<Entity> entities) {
++        this.entityManager.addWorldGenChunkEntities(entities);
+     }
+ 
+-    public void startTickingChunk(LevelChunk levelchunk) {
+-        levelchunk.unpackTicks(this.getLevelData().getGameTime());
++    public void startTickingChunk(LevelChunk chunk) {
++        chunk.unpackTicks(this.getLevelData().getGameTime());
+     }
+ 
+-    public void onStructureStartsAvailable(ChunkAccess chunkaccess) {
++    public void onStructureStartsAvailable(ChunkAccess chunk) {
+         this.server.execute(() -> {
+-            this.structureCheck.onStructureLoad(chunkaccess.getPos(), chunkaccess.getAllStarts());
++            this.structureCheck.onStructureLoad(chunk.getPos(), chunk.getAllStarts());
+         });
+     }
+ 
+     @Override
+-    @Override
+     public void close() throws IOException {
+         super.close();
+         this.entityManager.close();
+     }
+ 
+     @Override
+-    @Override
+     public String gatherChunkSourceStats() {
+         String s = this.chunkSource.gatherStats();
+ 
+         return "Chunks[S] W: " + s + " E: " + this.entityManager.gatherStats();
+     }
+ 
+-    public boolean areEntitiesLoaded(long i) {
+-        return this.entityManager.areEntitiesLoaded(i);
++    public boolean areEntitiesLoaded(long chunkPos) {
++        return this.entityManager.areEntitiesLoaded(chunkPos);
+     }
+ 
+-    private boolean isPositionTickingWithEntitiesLoaded(long i) {
+-        return this.areEntitiesLoaded(i) && this.chunkSource.isPositionTicking(i);
++    private boolean isPositionTickingWithEntitiesLoaded(long chunkPos) {
++        return this.areEntitiesLoaded(chunkPos) && this.chunkSource.isPositionTicking(chunkPos);
+     }
+ 
+-    public boolean isPositionEntityTicking(BlockPos blockpos) {
+-        return this.entityManager.canPositionTick(blockpos) && this.chunkSource.chunkMap.getDistanceManager().inEntityTickingRange(ChunkPos.asLong(blockpos));
++    public boolean isPositionEntityTicking(BlockPos pos) {
++        return this.entityManager.canPositionTick(pos) && this.chunkSource.chunkMap.getDistanceManager().inEntityTickingRange(ChunkPos.asLong(pos));
+     }
+ 
+-    public boolean isNaturalSpawningAllowed(BlockPos blockpos) {
+-        return this.entityManager.canPositionTick(blockpos);
++    public boolean isNaturalSpawningAllowed(BlockPos pos) {
++        return this.entityManager.canPositionTick(pos);
+     }
+ 
+-    public boolean isNaturalSpawningAllowed(ChunkPos chunkpos) {
+-        return this.entityManager.canPositionTick(chunkpos);
++    public boolean isNaturalSpawningAllowed(ChunkPos chunkPos) {
++        return this.entityManager.canPositionTick(chunkPos);
+     }
+ 
+     @Override
+-    @Override
+     public FeatureFlagSet enabledFeatures() {
+         return this.server.getWorldData().enabledFeatures();
+     }
+ 
+-    public RandomSource getRandomSequence(ResourceLocation resourcelocation) {
+-        return this.randomSequences.get(resourcelocation);
++    public RandomSource getRandomSequence(ResourceLocation location) {
++        return this.randomSequences.get(location);
+     }
+ 
+     public RandomSequences getRandomSequences() {
+@@ -1766,50 +1944,44 @@
+     }
+ 
+     @Override
+-    @Override
+-    public CrashReportCategory fillReportDetails(CrashReport crashreport) {
+-        CrashReportCategory crashreportcategory = super.fillReportDetails(crashreport);
++    public CrashReportCategory fillReportDetails(CrashReport report) {
++        CrashReportCategory crashreportsystemdetails = super.fillReportDetails(report);
+ 
+-        crashreportcategory.setDetail("Loaded entity count", () -> {
++        crashreportsystemdetails.setDetail("Loaded entity count", () -> {
+             return String.valueOf(this.entityManager.count());
+         });
+-        return crashreportcategory;
++        return crashreportsystemdetails;
+     }
+ 
+-    private final class EntityCallbacks implements LevelCallback<Entity> {
++    private final class a implements LevelCallback<Entity> {
+ 
+-        EntityCallbacks() {}
++        a() {}
+ 
+-        @Override
+         public void onCreated(Entity entity) {}
+ 
+-        @Override
+         public void onDestroyed(Entity entity) {
+             ServerLevel.this.getScoreboard().entityRemoved(entity);
+         }
+ 
+-        @Override
+         public void onTickingStart(Entity entity) {
+             ServerLevel.this.entityTickList.add(entity);
+         }
+ 
+-        @Override
+         public void onTickingEnd(Entity entity) {
+             ServerLevel.this.entityTickList.remove(entity);
+         }
+ 
+-        @Override
+         public void onTrackingStart(Entity entity) {
+             ServerLevel.this.getChunkSource().addEntity(entity);
+             if (entity instanceof ServerPlayer) {
+-                ServerPlayer serverplayer = (ServerPlayer) entity;
++                ServerPlayer entityplayer = (ServerPlayer) entity;
+ 
+-                ServerLevel.this.players.add(serverplayer);
++                ServerLevel.this.players.add(entityplayer);
+                 ServerLevel.this.updateSleepingPlayerList();
+             }
+ 
+             if (entity instanceof Mob) {
+-                Mob mob = (Mob) entity;
++                Mob entityinsentient = (Mob) entity;
+ 
+                 if (ServerLevel.this.isUpdatingNavigations) {
+                     String s = "onTrackingStart called during navigation iteration";
+@@ -1817,36 +1989,37 @@
+                     Util.logAndPauseIfInIde("onTrackingStart called during navigation iteration", new IllegalStateException("onTrackingStart called during navigation iteration"));
+                 }
+ 
+-                ServerLevel.this.navigatingMobs.add(mob);
++                ServerLevel.this.navigatingMobs.add(entityinsentient);
+             }
+ 
+             if (entity instanceof EnderDragon) {
+-                EnderDragon enderdragon = (EnderDragon) entity;
+-                EnderDragonPart[] aenderdragonpart = enderdragon.getSubEntities();
+-                int i = aenderdragonpart.length;
++                EnderDragon entityenderdragon = (EnderDragon) entity;
++                EnderDragonPart[] aentitycomplexpart = entityenderdragon.getSubEntities();
++                int i = aentitycomplexpart.length;
+ 
+                 for (int j = 0; j < i; ++j) {
+-                    EnderDragonPart enderdragonpart = aenderdragonpart[j];
++                    EnderDragonPart entitycomplexpart = aentitycomplexpart[j];
+ 
+-                    ServerLevel.this.dragonParts.put(enderdragonpart.getId(), enderdragonpart);
++                    ServerLevel.this.dragonParts.put(entitycomplexpart.getId(), entitycomplexpart);
+                 }
+             }
+ 
+             entity.updateDynamicGameEventListener(DynamicGameEventListener::add);
++            entity.inWorld = true; // CraftBukkit - Mark entity as in world
++            entity.valid = true; // CraftBukkit
+         }
+ 
+-        @Override
+         public void onTrackingEnd(Entity entity) {
+             ServerLevel.this.getChunkSource().removeEntity(entity);
+             if (entity instanceof ServerPlayer) {
+-                ServerPlayer serverplayer = (ServerPlayer) entity;
++                ServerPlayer entityplayer = (ServerPlayer) entity;
+ 
+-                ServerLevel.this.players.remove(serverplayer);
++                ServerLevel.this.players.remove(entityplayer);
+                 ServerLevel.this.updateSleepingPlayerList();
+             }
+ 
+             if (entity instanceof Mob) {
+-                Mob mob = (Mob) entity;
++                Mob entityinsentient = (Mob) entity;
+ 
+                 if (ServerLevel.this.isUpdatingNavigations) {
+                     String s = "onTrackingStart called during navigation iteration";
+@@ -1854,25 +2027,32 @@
+                     Util.logAndPauseIfInIde("onTrackingStart called during navigation iteration", new IllegalStateException("onTrackingStart called during navigation iteration"));
+                 }
+ 
+-                ServerLevel.this.navigatingMobs.remove(mob);
++                ServerLevel.this.navigatingMobs.remove(entityinsentient);
+             }
+ 
+             if (entity instanceof EnderDragon) {
+-                EnderDragon enderdragon = (EnderDragon) entity;
+-                EnderDragonPart[] aenderdragonpart = enderdragon.getSubEntities();
+-                int i = aenderdragonpart.length;
++                EnderDragon entityenderdragon = (EnderDragon) entity;
++                EnderDragonPart[] aentitycomplexpart = entityenderdragon.getSubEntities();
++                int i = aentitycomplexpart.length;
+ 
+                 for (int j = 0; j < i; ++j) {
+-                    EnderDragonPart enderdragonpart = aenderdragonpart[j];
++                    EnderDragonPart entitycomplexpart = aentitycomplexpart[j];
+ 
+-                    ServerLevel.this.dragonParts.remove(enderdragonpart.getId());
++                    ServerLevel.this.dragonParts.remove(entitycomplexpart.getId());
+                 }
+             }
+ 
+             entity.updateDynamicGameEventListener(DynamicGameEventListener::remove);
++            // CraftBukkit start
++            entity.valid = false;
++            if (!(entity instanceof ServerPlayer)) {
++                for (ServerPlayer player : players) {
++                    player.getBukkitEntity().onEntityRemove(entity);
++                }
++            }
++            // CraftBukkit end
+         }
+ 
+-        @Override
+         public void onSectionChange(Entity entity) {
+             entity.updateDynamicGameEventListener(DynamicGameEventListener::move);
+         }