Move CraftBukkit per-file patches

By: Initial <noreply+automated@papermc.io>

paper-server/patches/sources/net/minecraft/server/AdvancementDataPlayer.patch

@@ -0,0 +1,18 @@
+--- a/net/minecraft/server/AdvancementDataPlayer.java
++++ b/net/minecraft/server/AdvancementDataPlayer.java
+@@ -196,6 +196,7 @@
+             AdvancementHolder advancementholder = advancementdataworld.get(minecraftkey);
+ 
+             if (advancementholder == null) {
++                if (!minecraftkey.getNamespace().equals("minecraft")) return; // CraftBukkit
+                 AdvancementDataPlayer.LOGGER.warn("Ignored advancement '{}' in progress file {} - it doesn't exist anymore?", minecraftkey, this.playerSavePath);
+             } else {
+                 this.startProgress(advancementholder, advancementprogress);
+@@ -227,6 +228,7 @@
+             this.progressChanged.add(advancementholder);
+             flag = true;
+             if (!flag1 && advancementprogress.isDone()) {
++                this.player.level().getCraftServer().getPluginManager().callEvent(new org.bukkit.event.player.PlayerAdvancementDoneEvent(this.player.getBukkitEntity(), advancementholder.toBukkit())); // CraftBukkit
+                 advancementholder.value().rewards().grant(this.player);
+                 advancementholder.value().display().ifPresent((advancementdisplay) -> {
+                     if (advancementdisplay.shouldAnnounceChat() && this.player.serverLevel().getGameRules().getBoolean(GameRules.RULE_ANNOUNCE_ADVANCEMENTS)) {

paper-server/patches/sources/net/minecraft/server/AdvancementDataWorld.patch

@@ -0,0 +1,27 @@
+--- a/net/minecraft/server/AdvancementDataWorld.java
++++ b/net/minecraft/server/AdvancementDataWorld.java
+@@ -21,10 +21,14 @@
+ import net.minecraft.util.profiling.GameProfilerFiller;
+ import org.slf4j.Logger;
+ 
++// CraftBukkit start
++import java.util.HashMap;
++// CraftBukkit end
++
+ public class AdvancementDataWorld extends ResourceDataJson<Advancement> {
+ 
+     private static final Logger LOGGER = LogUtils.getLogger();
+-    public Map<MinecraftKey, AdvancementHolder> advancements = Map.of();
++    public Map<MinecraftKey, AdvancementHolder> advancements = new HashMap<>(); // CraftBukkit - SPIGOT-7734: mutable
+     private AdvancementTree tree = new AdvancementTree();
+     private final HolderLookup.a registries;
+ 
+@@ -40,7 +44,7 @@
+             this.validate(minecraftkey, advancement);
+             builder.put(minecraftkey, new AdvancementHolder(minecraftkey, advancement));
+         });
+-        this.advancements = builder.buildOrThrow();
++        this.advancements = new HashMap<>(builder.buildOrThrow()); // CraftBukkit - SPIGOT-7734: mutable
+         AdvancementTree advancementtree = new AdvancementTree();
+ 
+         advancementtree.addAll(this.advancements.values());

paper-server/patches/sources/net/minecraft/server/CustomFunctionData.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/server/CustomFunctionData.java
++++ b/net/minecraft/server/CustomFunctionData.java
+@@ -37,7 +37,7 @@
+     }
+ 
+     public CommandDispatcher<CommandListenerWrapper> getDispatcher() {
+-        return this.server.getCommands().getDispatcher();
++        return this.server.vanillaCommandDispatcher.getDispatcher(); // CraftBukkit
+     }
+ 
+     public void tick() {

paper-server/patches/sources/net/minecraft/server/DispenserRegistry.patch

@@ -0,0 +1,111 @@
+--- a/net/minecraft/server/DispenserRegistry.java
++++ b/net/minecraft/server/DispenserRegistry.java
+@@ -30,7 +30,13 @@
+ import net.minecraft.world.level.block.state.BlockBase;
+ import org.slf4j.Logger;
+ 
+-@SuppressForbidden(a = "System.out setup")
++// CraftBukkit start
++import net.minecraft.util.datafix.fixes.DataConverterFlattenData;
++import net.minecraft.util.datafix.fixes.DataConverterMaterialId;
++import net.minecraft.util.datafix.fixes.DataConverterSpawnEgg;
++
++@SuppressForbidden(reason = "System.out setup")
++// CraftBukkit end
+ public class DispenserRegistry {
+ 
+     public static final PrintStream STDOUT = System.out;
+@@ -42,6 +48,23 @@
+ 
+     public static void bootStrap() {
+         if (!DispenserRegistry.isBootstrapped) {
++            // CraftBukkit start
++            String name = DispenserRegistry.class.getSimpleName();
++            switch (name) {
++                case "DispenserRegistry":
++                    break;
++                case "Bootstrap":
++                    System.err.println("***************************************************************************");
++                    System.err.println("*** WARNING: This server jar may only be used for development purposes. ***");
++                    System.err.println("***************************************************************************");
++                    break;
++                default:
++                    System.err.println("**********************************************************************");
++                    System.err.println("*** WARNING: This server jar is unsupported, use at your own risk. ***");
++                    System.err.println("**********************************************************************");
++                    break;
++            }
++            // CraftBukkit end
+             DispenserRegistry.isBootstrapped = true;
+             Instant instant = Instant.now();
+ 
+@@ -61,6 +84,69 @@
+                     wrapStreams();
+                     DispenserRegistry.bootstrapDuration.set(Duration.between(instant, Instant.now()).toMillis());
+                 }
++                // CraftBukkit start - easier than fixing the decompile
++                DataConverterFlattenData.register(1008, "{Name:'minecraft:oak_sign',Properties:{rotation:'0'}}", "{Name:'minecraft:standing_sign',Properties:{rotation:'0'}}");
++                DataConverterFlattenData.register(1009, "{Name:'minecraft:oak_sign',Properties:{rotation:'1'}}", "{Name:'minecraft:standing_sign',Properties:{rotation:'1'}}");
++                DataConverterFlattenData.register(1010, "{Name:'minecraft:oak_sign',Properties:{rotation:'2'}}", "{Name:'minecraft:standing_sign',Properties:{rotation:'2'}}");
++                DataConverterFlattenData.register(1011, "{Name:'minecraft:oak_sign',Properties:{rotation:'3'}}", "{Name:'minecraft:standing_sign',Properties:{rotation:'3'}}");
++                DataConverterFlattenData.register(1012, "{Name:'minecraft:oak_sign',Properties:{rotation:'4'}}", "{Name:'minecraft:standing_sign',Properties:{rotation:'4'}}");
++                DataConverterFlattenData.register(1013, "{Name:'minecraft:oak_sign',Properties:{rotation:'5'}}", "{Name:'minecraft:standing_sign',Properties:{rotation:'5'}}");
++                DataConverterFlattenData.register(1014, "{Name:'minecraft:oak_sign',Properties:{rotation:'6'}}", "{Name:'minecraft:standing_sign',Properties:{rotation:'6'}}");
++                DataConverterFlattenData.register(1015, "{Name:'minecraft:oak_sign',Properties:{rotation:'7'}}", "{Name:'minecraft:standing_sign',Properties:{rotation:'7'}}");
++                DataConverterFlattenData.register(1016, "{Name:'minecraft:oak_sign',Properties:{rotation:'8'}}", "{Name:'minecraft:standing_sign',Properties:{rotation:'8'}}");
++                DataConverterFlattenData.register(1017, "{Name:'minecraft:oak_sign',Properties:{rotation:'9'}}", "{Name:'minecraft:standing_sign',Properties:{rotation:'9'}}");
++                DataConverterFlattenData.register(1018, "{Name:'minecraft:oak_sign',Properties:{rotation:'10'}}", "{Name:'minecraft:standing_sign',Properties:{rotation:'10'}}");
++                DataConverterFlattenData.register(1019, "{Name:'minecraft:oak_sign',Properties:{rotation:'11'}}", "{Name:'minecraft:standing_sign',Properties:{rotation:'11'}}");
++                DataConverterFlattenData.register(1020, "{Name:'minecraft:oak_sign',Properties:{rotation:'12'}}", "{Name:'minecraft:standing_sign',Properties:{rotation:'12'}}");
++                DataConverterFlattenData.register(1021, "{Name:'minecraft:oak_sign',Properties:{rotation:'13'}}", "{Name:'minecraft:standing_sign',Properties:{rotation:'13'}}");
++                DataConverterFlattenData.register(1022, "{Name:'minecraft:oak_sign',Properties:{rotation:'14'}}", "{Name:'minecraft:standing_sign',Properties:{rotation:'14'}}");
++                DataConverterFlattenData.register(1023, "{Name:'minecraft:oak_sign',Properties:{rotation:'15'}}", "{Name:'minecraft:standing_sign',Properties:{rotation:'15'}}");
++                DataConverterMaterialId.ITEM_NAMES.put(323, "minecraft:oak_sign");
++
++                DataConverterFlattenData.register(1440, "{Name:\'minecraft:portal\',Properties:{axis:\'x\'}}", new String[]{"{Name:\'minecraft:portal\',Properties:{axis:\'x\'}}"});
++
++                DataConverterMaterialId.ITEM_NAMES.put(409, "minecraft:prismarine_shard");
++                DataConverterMaterialId.ITEM_NAMES.put(410, "minecraft:prismarine_crystals");
++                DataConverterMaterialId.ITEM_NAMES.put(411, "minecraft:rabbit");
++                DataConverterMaterialId.ITEM_NAMES.put(412, "minecraft:cooked_rabbit");
++                DataConverterMaterialId.ITEM_NAMES.put(413, "minecraft:rabbit_stew");
++                DataConverterMaterialId.ITEM_NAMES.put(414, "minecraft:rabbit_foot");
++                DataConverterMaterialId.ITEM_NAMES.put(415, "minecraft:rabbit_hide");
++                DataConverterMaterialId.ITEM_NAMES.put(416, "minecraft:armor_stand");
++
++                DataConverterMaterialId.ITEM_NAMES.put(423, "minecraft:mutton");
++                DataConverterMaterialId.ITEM_NAMES.put(424, "minecraft:cooked_mutton");
++                DataConverterMaterialId.ITEM_NAMES.put(425, "minecraft:banner");
++                DataConverterMaterialId.ITEM_NAMES.put(426, "minecraft:end_crystal");
++                DataConverterMaterialId.ITEM_NAMES.put(427, "minecraft:spruce_door");
++                DataConverterMaterialId.ITEM_NAMES.put(428, "minecraft:birch_door");
++                DataConverterMaterialId.ITEM_NAMES.put(429, "minecraft:jungle_door");
++                DataConverterMaterialId.ITEM_NAMES.put(430, "minecraft:acacia_door");
++                DataConverterMaterialId.ITEM_NAMES.put(431, "minecraft:dark_oak_door");
++                DataConverterMaterialId.ITEM_NAMES.put(432, "minecraft:chorus_fruit");
++                DataConverterMaterialId.ITEM_NAMES.put(433, "minecraft:chorus_fruit_popped");
++                DataConverterMaterialId.ITEM_NAMES.put(434, "minecraft:beetroot");
++                DataConverterMaterialId.ITEM_NAMES.put(435, "minecraft:beetroot_seeds");
++                DataConverterMaterialId.ITEM_NAMES.put(436, "minecraft:beetroot_soup");
++                DataConverterMaterialId.ITEM_NAMES.put(437, "minecraft:dragon_breath");
++                DataConverterMaterialId.ITEM_NAMES.put(438, "minecraft:splash_potion");
++                DataConverterMaterialId.ITEM_NAMES.put(439, "minecraft:spectral_arrow");
++                DataConverterMaterialId.ITEM_NAMES.put(440, "minecraft:tipped_arrow");
++                DataConverterMaterialId.ITEM_NAMES.put(441, "minecraft:lingering_potion");
++                DataConverterMaterialId.ITEM_NAMES.put(442, "minecraft:shield");
++                DataConverterMaterialId.ITEM_NAMES.put(443, "minecraft:elytra");
++                DataConverterMaterialId.ITEM_NAMES.put(444, "minecraft:spruce_boat");
++                DataConverterMaterialId.ITEM_NAMES.put(445, "minecraft:birch_boat");
++                DataConverterMaterialId.ITEM_NAMES.put(446, "minecraft:jungle_boat");
++                DataConverterMaterialId.ITEM_NAMES.put(447, "minecraft:acacia_boat");
++                DataConverterMaterialId.ITEM_NAMES.put(448, "minecraft:dark_oak_boat");
++                DataConverterMaterialId.ITEM_NAMES.put(449, "minecraft:totem_of_undying");
++                DataConverterMaterialId.ITEM_NAMES.put(450, "minecraft:shulker_shell");
++                DataConverterMaterialId.ITEM_NAMES.put(452, "minecraft:iron_nugget");
++                DataConverterMaterialId.ITEM_NAMES.put(453, "minecraft:knowledge_book");
++
++                DataConverterSpawnEgg.ID_TO_ENTITY[23] = "Arrow";
++                // CraftBukkit end
+             }
+         }
+     }

paper-server/patches/sources/net/minecraft/server/Main.patch

@@ -0,0 +1,219 @@
+--- a/net/minecraft/server/Main.java
++++ b/net/minecraft/server/Main.java
+@@ -61,16 +61,28 @@
+ import net.minecraft.world.level.storage.WorldInfo;
+ import org.slf4j.Logger;
+ 
++// CraftBukkit start
++import com.google.common.base.Charsets;
++import java.io.InputStreamReader;
++import java.util.concurrent.atomic.AtomicReference;
++import net.minecraft.SharedConstants;
++import net.minecraft.server.packs.EnumResourcePackType;
++import net.minecraft.world.level.dimension.WorldDimension;
++import net.minecraft.world.level.storage.SavedFile;
++import org.bukkit.configuration.file.YamlConfiguration;
++// CraftBukkit end
++
+ public class Main {
+ 
+     private static final Logger LOGGER = LogUtils.getLogger();
+ 
+     public Main() {}
+ 
+-    @SuppressForbidden(a = "System.out needed before bootstrap")
++    @SuppressForbidden(reason = "System.out needed before bootstrap") // CraftBukkit - decompile error
+     @DontObfuscate
+-    public static void main(String[] astring) {
++    public static void main(final OptionSet optionset) { // CraftBukkit - replaces main(String[] astring)
+         SharedConstants.tryDetectVersion();
++        /* CraftBukkit start - Replace everything
+         OptionParser optionparser = new OptionParser();
+         OptionSpec<Void> optionspec = optionparser.accepts("nogui");
+         OptionSpec<Void> optionspec1 = optionparser.accepts("initSettings", "Initializes 'server.properties' and 'eula.txt', then quits");
+@@ -96,15 +108,18 @@
+                 optionparser.printHelpOn(System.err);
+                 return;
+             }
++            */ // CraftBukkit end
+ 
+-            Path path = (Path) optionset.valueOf(optionspec14);
++        try {
++
++            Path path = (Path) optionset.valueOf("pidFile"); // CraftBukkit
+ 
+             if (path != null) {
+                 writePidFile(path);
+             }
+ 
+             CrashReport.preload();
+-            if (optionset.has(optionspec13)) {
++            if (optionset.has("jfrProfile")) { // CraftBukkit
+                 JvmProfiler.INSTANCE.start(Environment.SERVER);
+             }
+ 
+@@ -112,14 +127,27 @@
+             DispenserRegistry.validate();
+             SystemUtils.startTimerHackThread();
+             Path path1 = Paths.get("server.properties");
+-            DedicatedServerSettings dedicatedserversettings = new DedicatedServerSettings(path1);
++            DedicatedServerSettings dedicatedserversettings = new DedicatedServerSettings(optionset); // CraftBukkit - CLI argument support
+ 
+             dedicatedserversettings.forceSave();
+             RegionFileCompression.configure(dedicatedserversettings.getProperties().regionFileComression);
+             Path path2 = Paths.get("eula.txt");
+             EULA eula = new EULA(path2);
+ 
+-            if (optionset.has(optionspec1)) {
++            if (optionset.has("initSettings")) { // CraftBukkit
++                // CraftBukkit start - SPIGOT-5761: Create bukkit.yml and commands.yml if not present
++                File configFile = (File) optionset.valueOf("bukkit-settings");
++                YamlConfiguration configuration = YamlConfiguration.loadConfiguration(configFile);
++                configuration.options().copyDefaults(true);
++                configuration.setDefaults(YamlConfiguration.loadConfiguration(new InputStreamReader(Main.class.getClassLoader().getResourceAsStream("configurations/bukkit.yml"), Charsets.UTF_8)));
++                configuration.save(configFile);
++
++                File commandFile = (File) optionset.valueOf("commands-settings");
++                YamlConfiguration commandsConfiguration = YamlConfiguration.loadConfiguration(commandFile);
++                commandsConfiguration.options().copyDefaults(true);
++                commandsConfiguration.setDefaults(YamlConfiguration.loadConfiguration(new InputStreamReader(Main.class.getClassLoader().getResourceAsStream("configurations/commands.yml"), Charsets.UTF_8)));
++                commandsConfiguration.save(commandFile);
++                // CraftBukkit end
+                 Main.LOGGER.info("Initialized '{}' and '{}'", path1.toAbsolutePath(), path2.toAbsolutePath());
+                 return;
+             }
+@@ -129,11 +157,13 @@
+                 return;
+             }
+ 
+-            File file = new File((String) optionset.valueOf(optionspec9));
++            File file = (File) optionset.valueOf("universe"); // CraftBukkit
+             Services services = Services.create(new YggdrasilAuthenticationService(Proxy.NO_PROXY), file);
+-            String s = (String) Optional.ofNullable((String) optionset.valueOf(optionspec10)).orElse(dedicatedserversettings.getProperties().levelName);
++            // CraftBukkit start
++            String s = (String) Optional.ofNullable((String) optionset.valueOf("world")).orElse(dedicatedserversettings.getProperties().levelName);
+             Convertable convertable = Convertable.createDefault(file.toPath());
+-            Convertable.ConversionSession convertable_conversionsession = convertable.validateAndCreateAccess(s);
++            Convertable.ConversionSession convertable_conversionsession = convertable.validateAndCreateAccess(s, WorldDimension.OVERWORLD);
++            // CraftBukkit end
+             Dynamic dynamic;
+ 
+             if (convertable_conversionsession.hasWorldData()) {
+@@ -174,13 +204,31 @@
+             }
+ 
+             Dynamic<?> dynamic1 = dynamic;
+-            boolean flag = optionset.has(optionspec7);
++            boolean flag = optionset.has("safeMode"); // CraftBukkit
+ 
+             if (flag) {
+                 Main.LOGGER.warn("Safe mode active, only vanilla datapack will be loaded");
+             }
+ 
+             ResourcePackRepository resourcepackrepository = ResourcePackSourceVanilla.createPackRepository(convertable_conversionsession);
++            // CraftBukkit start
++            File bukkitDataPackFolder = new File(convertable_conversionsession.getLevelPath(SavedFile.DATAPACK_DIR).toFile(), "bukkit");
++            if (!bukkitDataPackFolder.exists()) {
++                bukkitDataPackFolder.mkdirs();
++            }
++            File mcMeta = new File(bukkitDataPackFolder, "pack.mcmeta");
++            try {
++                com.google.common.io.Files.write("{\n"
++                        + "    \"pack\": {\n"
++                        + "        \"description\": \"Data pack for resources provided by Bukkit plugins\",\n"
++                        + "        \"pack_format\": " + SharedConstants.getCurrentVersion().getPackVersion(EnumResourcePackType.SERVER_DATA) + "\n"
++                        + "    }\n"
++                        + "}\n", mcMeta, com.google.common.base.Charsets.UTF_8);
++            } catch (java.io.IOException ex) {
++                throw new RuntimeException("Could not initialize Bukkit datapack", ex);
++            }
++            AtomicReference<WorldLoader.a> worldLoader = new AtomicReference<>();
++            // CraftBukkit end
+ 
+             WorldStem worldstem;
+ 
+@@ -189,6 +237,7 @@
+ 
+                 worldstem = (WorldStem) SystemUtils.blockUntilDone((executor) -> {
+                     return WorldLoader.load(worldloader_c, (worldloader_a) -> {
++                        worldLoader.set(worldloader_a); // CraftBukkit
+                         IRegistry<WorldDimension> iregistry = worldloader_a.datapackDimensions().lookupOrThrow(Registries.LEVEL_STEM);
+ 
+                         if (dynamic1 != null) {
+@@ -201,7 +250,7 @@
+                             WorldOptions worldoptions;
+                             WorldDimensions worlddimensions;
+ 
+-                            if (optionset.has(optionspec2)) {
++                            if (optionset.has("demo")) { // CraftBukkit
+                                 worldsettings = MinecraftServer.DEMO_SETTINGS;
+                                 worldoptions = WorldOptions.DEMO_OPTIONS;
+                                 worlddimensions = WorldPresets.createNormalWorldDimensions(worldloader_a.datapackWorldgen());
+@@ -209,7 +258,7 @@
+                                 DedicatedServerProperties dedicatedserverproperties = dedicatedserversettings.getProperties();
+ 
+                                 worldsettings = new WorldSettings(dedicatedserverproperties.levelName, dedicatedserverproperties.gamemode, dedicatedserverproperties.hardcore, dedicatedserverproperties.difficulty, false, new GameRules(worldloader_a.dataConfiguration().enabledFeatures()), worldloader_a.dataConfiguration());
+-                                worldoptions = optionset.has(optionspec3) ? dedicatedserverproperties.worldOptions.withBonusChest(true) : dedicatedserverproperties.worldOptions;
++                                worldoptions = optionset.has("bonusChest") ? dedicatedserverproperties.worldOptions.withBonusChest(true) : dedicatedserverproperties.worldOptions; // CraftBukkit
+                                 worlddimensions = dedicatedserverproperties.createDimensions(worldloader_a.datapackWorldgen());
+                             }
+ 
+@@ -225,6 +274,7 @@
+                 return;
+             }
+ 
++            /*
+             IRegistryCustom.Dimension iregistrycustom_dimension = worldstem.registries().compositeAccess();
+             boolean flag1 = optionset.has(optionspec6);
+ 
+@@ -237,20 +287,31 @@
+             SaveData savedata = worldstem.worldData();
+ 
+             convertable_conversionsession.saveDataTag(iregistrycustom_dimension, savedata);
++            */
+             final DedicatedServer dedicatedserver = (DedicatedServer) MinecraftServer.spin((thread) -> {
+-                DedicatedServer dedicatedserver1 = new DedicatedServer(thread, convertable_conversionsession, resourcepackrepository, worldstem, dedicatedserversettings, DataConverterRegistry.getDataFixer(), services, WorldLoadListenerLogger::createFromGameruleRadius);
++                DedicatedServer dedicatedserver1 = new DedicatedServer(optionset, worldLoader.get(), thread, convertable_conversionsession, resourcepackrepository, worldstem, dedicatedserversettings, DataConverterRegistry.getDataFixer(), services, WorldLoadListenerLogger::createFromGameruleRadius);
+ 
++                /*
+                 dedicatedserver1.setPort((Integer) optionset.valueOf(optionspec11));
+                 dedicatedserver1.setDemo(optionset.has(optionspec2));
+                 dedicatedserver1.setId((String) optionset.valueOf(optionspec12));
+-                boolean flag2 = !optionset.has(optionspec) && !optionset.valuesOf(optionspec15).contains("nogui");
++                */
++                boolean flag2 = !optionset.has("nogui") && !optionset.nonOptionArguments().contains("nogui");
+ 
+                 if (flag2 && !GraphicsEnvironment.isHeadless()) {
+                     dedicatedserver1.showGui();
+                 }
+ 
++                if (optionset.has("port")) {
++                    int port = (Integer) optionset.valueOf("port");
++                    if (port > 0) {
++                        dedicatedserver1.setPort(port);
++                    }
++                }
++
+                 return dedicatedserver1;
+             });
++            /* CraftBukkit start
+             Thread thread = new Thread("Server Shutdown Thread") {
+                 public void run() {
+                     dedicatedserver.halt(true);
+@@ -259,6 +320,7 @@
+ 
+             thread.setUncaughtExceptionHandler(new DefaultUncaughtExceptionHandler(Main.LOGGER));
+             Runtime.getRuntime().addShutdownHook(thread);
++            */ // CraftBukkit end
+         } catch (Exception exception1) {
+             Main.LOGGER.error(LogUtils.FATAL_MARKER, "Failed to start the minecraft server", exception1);
+         }
+@@ -295,7 +357,7 @@
+     }
+ 
+     public static void forceUpgrade(Convertable.ConversionSession convertable_conversionsession, DataFixer datafixer, boolean flag, BooleanSupplier booleansupplier, IRegistryCustom iregistrycustom, boolean flag1) {
+-        Main.LOGGER.info("Forcing world upgrade!");
++        Main.LOGGER.info("Forcing world upgrade! {}", convertable_conversionsession.getLevelId()); // CraftBukkit
+         WorldUpgrader worldupgrader = new WorldUpgrader(convertable_conversionsession, datafixer, iregistrycustom, flag, flag1);
+ 
+         try {

paper-server/patches/sources/net/minecraft/server/MinecraftServer.patch

@@ -0,0 +1,801 @@
+--- a/net/minecraft/server/MinecraftServer.java
++++ b/net/minecraft/server/MinecraftServer.java
+@@ -180,13 +180,38 @@
+ import net.minecraft.world.phys.Vec3D;
+ import org.slf4j.Logger;
+ 
++// CraftBukkit start
++import com.mojang.serialization.Dynamic;
++import com.mojang.serialization.Lifecycle;
++import java.io.File;
++import java.util.Random;
++import jline.console.ConsoleReader;
++import joptsimple.OptionSet;
++import net.minecraft.nbt.NbtException;
++import net.minecraft.nbt.ReportedNbtException;
++import net.minecraft.server.dedicated.DedicatedServer;
++import net.minecraft.server.dedicated.DedicatedServerProperties;
++import net.minecraft.util.datafix.DataConverterRegistry;
++import net.minecraft.world.level.levelgen.WorldDimensions;
++import net.minecraft.world.level.levelgen.presets.WorldPresets;
++import net.minecraft.world.level.storage.LevelDataAndDimensions;
++import net.minecraft.world.level.storage.WorldDataServer;
++import net.minecraft.world.level.storage.WorldInfo;
++import net.minecraft.world.level.validation.ContentValidationException;
++import org.bukkit.Bukkit;
++import org.bukkit.craftbukkit.CraftRegistry;
++import org.bukkit.craftbukkit.CraftServer;
++import org.bukkit.craftbukkit.Main;
++import org.bukkit.event.server.ServerLoadEvent;
++// CraftBukkit end
++
+ public abstract class MinecraftServer extends IAsyncTaskHandlerReentrant<TickTask> implements ServerInfo, ChunkIOErrorReporter, ICommandListener {
+ 
+     public static final Logger LOGGER = LogUtils.getLogger();
+     public static final String VANILLA_BRAND = "vanilla";
+     private static final float AVERAGE_TICK_TIME_SMOOTHING = 0.8F;
+     private static final int TICK_STATS_SPAN = 100;
+-    private static final long OVERLOADED_THRESHOLD_NANOS = 20L * TimeRange.NANOSECONDS_PER_SECOND / 20L;
++    private static final long OVERLOADED_THRESHOLD_NANOS = 30L * TimeRange.NANOSECONDS_PER_SECOND / 20L; // CraftBukkit
+     private static final int OVERLOADED_TICKS_THRESHOLD = 20;
+     private static final long OVERLOADED_WARNING_INTERVAL_NANOS = 10L * TimeRange.NANOSECONDS_PER_SECOND;
+     private static final int OVERLOADED_TICKS_WARNING_INTERVAL = 100;
+@@ -277,6 +302,19 @@
+     private final SuppressedExceptionCollector suppressedExceptions;
+     private final DiscontinuousFrame tickFrame;
+ 
++    // CraftBukkit start
++    public final WorldLoader.a worldLoader;
++    public org.bukkit.craftbukkit.CraftServer server;
++    public OptionSet options;
++    public org.bukkit.command.ConsoleCommandSender console;
++    public ConsoleReader reader;
++    public static int currentTick = (int) (System.currentTimeMillis() / 50);
++    public java.util.Queue<Runnable> processQueue = new java.util.concurrent.ConcurrentLinkedQueue<Runnable>();
++    public int autosavePeriod;
++    public CommandDispatcher vanillaCommandDispatcher;
++    private boolean forceTicks;
++    // CraftBukkit end
++
+     public static <S extends MinecraftServer> S spin(Function<Thread, S> function) {
+         AtomicReference<S> atomicreference = new AtomicReference();
+         Thread thread = new Thread(() -> {
+@@ -290,14 +328,14 @@
+             thread.setPriority(8);
+         }
+ 
+-        S s0 = (MinecraftServer) function.apply(thread);
++        S s0 = function.apply(thread); // CraftBukkit - decompile error
+ 
+         atomicreference.set(s0);
+         thread.start();
+         return s0;
+     }
+ 
+-    public MinecraftServer(Thread thread, Convertable.ConversionSession convertable_conversionsession, ResourcePackRepository resourcepackrepository, WorldStem worldstem, Proxy proxy, DataFixer datafixer, Services services, WorldLoadListenerFactory worldloadlistenerfactory) {
++    public MinecraftServer(OptionSet options, WorldLoader.a worldLoader, Thread thread, Convertable.ConversionSession convertable_conversionsession, ResourcePackRepository resourcepackrepository, WorldStem worldstem, Proxy proxy, DataFixer datafixer, Services services, WorldLoadListenerFactory worldloadlistenerfactory) {
+         super("Server");
+         this.metricsRecorder = InactiveMetricsRecorder.INSTANCE;
+         this.onMetricsRecordingStopped = (methodprofilerresults) -> {
+@@ -321,7 +359,7 @@
+         this.suppressedExceptions = new SuppressedExceptionCollector();
+         this.registries = worldstem.registries();
+         this.worldData = worldstem.worldData();
+-        if (!this.registries.compositeAccess().lookupOrThrow(Registries.LEVEL_STEM).containsKey(WorldDimension.OVERWORLD)) {
++        if (false && !this.registries.compositeAccess().lookupOrThrow(Registries.LEVEL_STEM).containsKey(WorldDimension.OVERWORLD)) { // CraftBukkit - initialised later
+             throw new IllegalStateException("Missing Overworld dimension data");
+         } else {
+             this.proxy = proxy;
+@@ -349,6 +387,33 @@
+             this.fuelValues = FuelValues.vanillaBurnTimes(this.registries.compositeAccess(), this.worldData.enabledFeatures());
+             this.tickFrame = TracyClient.createDiscontinuousFrame("Server Tick");
+         }
++        // CraftBukkit start
++        this.options = options;
++        this.worldLoader = worldLoader;
++        this.vanillaCommandDispatcher = worldstem.dataPackResources().commands; // CraftBukkit
++        // Try to see if we're actually running in a terminal, disable jline if not
++        if (System.console() == null && System.getProperty("jline.terminal") == null) {
++            System.setProperty("jline.terminal", "jline.UnsupportedTerminal");
++            Main.useJline = false;
++        }
++
++        try {
++            reader = new ConsoleReader(System.in, System.out);
++            reader.setExpandEvents(false); // Avoid parsing exceptions for uncommonly used event designators
++        } catch (Throwable e) {
++            try {
++                // Try again with jline disabled for Windows users without C++ 2008 Redistributable
++                System.setProperty("jline.terminal", "jline.UnsupportedTerminal");
++                System.setProperty("user.language", "en");
++                Main.useJline = false;
++                reader = new ConsoleReader(System.in, System.out);
++                reader.setExpandEvents(false);
++            } catch (IOException ex) {
++                LOGGER.warn((String) null, ex);
++            }
++        }
++        Runtime.getRuntime().addShutdownHook(new org.bukkit.craftbukkit.util.ServerShutdownThread(this));
++        // CraftBukkit end
+     }
+ 
+     private void readScoreboard(WorldPersistentData worldpersistentdata) {
+@@ -357,7 +422,7 @@
+ 
+     protected abstract boolean initServer() throws IOException;
+ 
+-    protected void loadLevel() {
++    protected void loadLevel(String s) { // CraftBukkit
+         if (!JvmProfiler.INSTANCE.isRunning()) {
+             ;
+         }
+@@ -365,12 +430,8 @@
+         boolean flag = false;
+         ProfiledDuration profiledduration = JvmProfiler.INSTANCE.onWorldLoadedStarted();
+ 
+-        this.worldData.setModdedInfo(this.getServerModName(), this.getModdedStatus().shouldReportAsModified());
+-        WorldLoadListener worldloadlistener = this.progressListenerFactory.create(this.worldData.getGameRules().getInt(GameRules.RULE_SPAWN_CHUNK_RADIUS));
++        loadWorld0(s); // CraftBukkit
+ 
+-        this.createLevels(worldloadlistener);
+-        this.forceDifficulty();
+-        this.prepareLevels(worldloadlistener);
+         if (profiledduration != null) {
+             profiledduration.finish(true);
+         }
+@@ -387,23 +448,217 @@
+ 
+     protected void forceDifficulty() {}
+ 
+-    protected void createLevels(WorldLoadListener worldloadlistener) {
+-        IWorldDataServer iworlddataserver = this.worldData.overworldData();
+-        boolean flag = this.worldData.isDebugWorld();
+-        IRegistry<WorldDimension> iregistry = this.registries.compositeAccess().lookupOrThrow(Registries.LEVEL_STEM);
+-        WorldOptions worldoptions = this.worldData.worldGenOptions();
+-        long i = worldoptions.seed();
+-        long j = BiomeManager.obfuscateSeed(i);
+-        List<MobSpawner> list = ImmutableList.of(new MobSpawnerPhantom(), new MobSpawnerPatrol(), new MobSpawnerCat(), new VillageSiege(), new MobSpawnerTrader(iworlddataserver));
+-        WorldDimension worlddimension = (WorldDimension) iregistry.getValue(WorldDimension.OVERWORLD);
+-        WorldServer worldserver = new WorldServer(this, this.executor, this.storageSource, iworlddataserver, World.OVERWORLD, worlddimension, worldloadlistener, flag, j, list, true, (RandomSequences) null);
++    // CraftBukkit start
++    private void loadWorld0(String s) {
++        Convertable.ConversionSession worldSession = this.storageSource;
+ 
+-        this.levels.put(World.OVERWORLD, worldserver);
+-        WorldPersistentData worldpersistentdata = worldserver.getDataStorage();
++        IRegistryCustom.Dimension iregistrycustom_dimension = this.registries.compositeAccess();
++        IRegistry<WorldDimension> dimensions = iregistrycustom_dimension.lookupOrThrow(Registries.LEVEL_STEM);
++        for (WorldDimension worldDimension : dimensions) {
++            ResourceKey<WorldDimension> dimensionKey = dimensions.getResourceKey(worldDimension).get();
+ 
+-        this.readScoreboard(worldpersistentdata);
+-        this.commandStorage = new PersistentCommandStorage(worldpersistentdata);
++            WorldServer world;
++            int dimension = 0;
++
++            if (dimensionKey == WorldDimension.NETHER) {
++                if (server.getAllowNether()) {
++                    dimension = -1;
++                } else {
++                    continue;
++                }
++            } else if (dimensionKey == WorldDimension.END) {
++                if (server.getAllowEnd()) {
++                    dimension = 1;
++                } else {
++                    continue;
++                }
++            } else if (dimensionKey != WorldDimension.OVERWORLD) {
++                dimension = -999;
++            }
++
++            String worldType = (dimension == -999) ? dimensionKey.location().getNamespace() + "_" + dimensionKey.location().getPath() : org.bukkit.World.Environment.getEnvironment(dimension).toString().toLowerCase(Locale.ROOT);
++            String name = (dimensionKey == WorldDimension.OVERWORLD) ? s : s + "_" + worldType;
++            if (dimension != 0) {
++                File newWorld = Convertable.getStorageFolder(new File(name).toPath(), dimensionKey).toFile();
++                File oldWorld = Convertable.getStorageFolder(new File(s).toPath(), dimensionKey).toFile();
++                File oldLevelDat = new File(new File(s), "level.dat"); // The data folders exist on first run as they are created in the PersistentCollection constructor above, but the level.dat won't
++
++                if (!newWorld.isDirectory() && oldWorld.isDirectory() && oldLevelDat.isFile()) {
++                    MinecraftServer.LOGGER.info("---- Migration of old " + worldType + " folder required ----");
++                    MinecraftServer.LOGGER.info("Unfortunately due to the way that Minecraft implemented multiworld support in 1.6, Bukkit requires that you move your " + worldType + " folder to a new location in order to operate correctly.");
++                    MinecraftServer.LOGGER.info("We will move this folder for you, but it will mean that you need to move it back should you wish to stop using Bukkit in the future.");
++                    MinecraftServer.LOGGER.info("Attempting to move " + oldWorld + " to " + newWorld + "...");
++
++                    if (newWorld.exists()) {
++                        MinecraftServer.LOGGER.warn("A file or folder already exists at " + newWorld + "!");
++                        MinecraftServer.LOGGER.info("---- Migration of old " + worldType + " folder failed ----");
++                    } else if (newWorld.getParentFile().mkdirs()) {
++                        if (oldWorld.renameTo(newWorld)) {
++                            MinecraftServer.LOGGER.info("Success! To restore " + worldType + " in the future, simply move " + newWorld + " to " + oldWorld);
++                            // Migrate world data too.
++                            try {
++                                com.google.common.io.Files.copy(oldLevelDat, new File(new File(name), "level.dat"));
++                                org.apache.commons.io.FileUtils.copyDirectory(new File(new File(s), "data"), new File(new File(name), "data"));
++                            } catch (IOException exception) {
++                                MinecraftServer.LOGGER.warn("Unable to migrate world data.");
++                            }
++                            MinecraftServer.LOGGER.info("---- Migration of old " + worldType + " folder complete ----");
++                        } else {
++                            MinecraftServer.LOGGER.warn("Could not move folder " + oldWorld + " to " + newWorld + "!");
++                            MinecraftServer.LOGGER.info("---- Migration of old " + worldType + " folder failed ----");
++                        }
++                    } else {
++                        MinecraftServer.LOGGER.warn("Could not create path for " + newWorld + "!");
++                        MinecraftServer.LOGGER.info("---- Migration of old " + worldType + " folder failed ----");
++                    }
++                }
++
++                try {
++                    worldSession = Convertable.createDefault(server.getWorldContainer().toPath()).validateAndCreateAccess(name, dimensionKey);
++                } catch (IOException | ContentValidationException ex) {
++                    throw new RuntimeException(ex);
++                }
++            }
++
++            Dynamic<?> dynamic;
++            if (worldSession.hasWorldData()) {
++                WorldInfo worldinfo;
++
++                try {
++                    dynamic = worldSession.getDataTag();
++                    worldinfo = worldSession.getSummary(dynamic);
++                } catch (NbtException | ReportedNbtException | IOException ioexception) {
++                    Convertable.b convertable_b = worldSession.getLevelDirectory();
++
++                    MinecraftServer.LOGGER.warn("Failed to load world data from {}", convertable_b.dataFile(), ioexception);
++                    MinecraftServer.LOGGER.info("Attempting to use fallback");
++
++                    try {
++                        dynamic = worldSession.getDataTagFallback();
++                        worldinfo = worldSession.getSummary(dynamic);
++                    } catch (NbtException | ReportedNbtException | IOException ioexception1) {
++                        MinecraftServer.LOGGER.error("Failed to load world data from {}", convertable_b.oldDataFile(), ioexception1);
++                        MinecraftServer.LOGGER.error("Failed to load world data from {} and {}. World files may be corrupted. Shutting down.", convertable_b.dataFile(), convertable_b.oldDataFile());
++                        return;
++                    }
++
++                    worldSession.restoreLevelDataFromOld();
++                }
++
++                if (worldinfo.requiresManualConversion()) {
++                    MinecraftServer.LOGGER.info("This world must be opened in an older version (like 1.6.4) to be safely converted");
++                    return;
++                }
++
++                if (!worldinfo.isCompatible()) {
++                    MinecraftServer.LOGGER.info("This world was created by an incompatible version.");
++                    return;
++                }
++            } else {
++                dynamic = null;
++            }
++
++            org.bukkit.generator.ChunkGenerator gen = this.server.getGenerator(name);
++            org.bukkit.generator.BiomeProvider biomeProvider = this.server.getBiomeProvider(name);
++
++            WorldDataServer worlddata;
++            WorldLoader.a worldloader_a = this.worldLoader;
++            IRegistry<WorldDimension> iregistry = worldloader_a.datapackDimensions().lookupOrThrow(Registries.LEVEL_STEM);
++            if (dynamic != null) {
++                LevelDataAndDimensions leveldataanddimensions = Convertable.getLevelDataAndDimensions(dynamic, worldloader_a.dataConfiguration(), iregistry, worldloader_a.datapackWorldgen());
++
++                worlddata = (WorldDataServer) leveldataanddimensions.worldData();
++            } else {
++                WorldSettings worldsettings;
++                WorldOptions worldoptions;
++                WorldDimensions worlddimensions;
++
++                if (this.isDemo()) {
++                    worldsettings = MinecraftServer.DEMO_SETTINGS;
++                    worldoptions = WorldOptions.DEMO_OPTIONS;
++                    worlddimensions = WorldPresets.createNormalWorldDimensions(worldloader_a.datapackWorldgen());
++                } else {
++                    DedicatedServerProperties dedicatedserverproperties = ((DedicatedServer) this).getProperties();
++
++                    worldsettings = new WorldSettings(dedicatedserverproperties.levelName, dedicatedserverproperties.gamemode, dedicatedserverproperties.hardcore, dedicatedserverproperties.difficulty, false, new GameRules(worldloader_a.dataConfiguration().enabledFeatures()), worldloader_a.dataConfiguration());
++                    worldoptions = options.has("bonusChest") ? dedicatedserverproperties.worldOptions.withBonusChest(true) : dedicatedserverproperties.worldOptions;
++                    worlddimensions = dedicatedserverproperties.createDimensions(worldloader_a.datapackWorldgen());
++                }
++
++                WorldDimensions.b worlddimensions_b = worlddimensions.bake(iregistry);
++                Lifecycle lifecycle = worlddimensions_b.lifecycle().add(worldloader_a.datapackWorldgen().allRegistriesLifecycle());
++
++                worlddata = new WorldDataServer(worldsettings, worldoptions, worlddimensions_b.specialWorldProperty(), lifecycle);
++            }
++            worlddata.checkName(name); // CraftBukkit - Migration did not rewrite the level.dat; This forces 1.8 to take the last loaded world as respawn (in this case the end)
++            if (options.has("forceUpgrade")) {
++                net.minecraft.server.Main.forceUpgrade(worldSession, DataConverterRegistry.getDataFixer(), options.has("eraseCache"), () -> {
++                    return true;
++                }, iregistrycustom_dimension, options.has("recreateRegionFiles"));
++            }
++
++            WorldDataServer iworlddataserver = worlddata;
++            boolean flag = worlddata.isDebugWorld();
++            WorldOptions worldoptions = worlddata.worldGenOptions();
++            long i = worldoptions.seed();
++            long j = BiomeManager.obfuscateSeed(i);
++            List<MobSpawner> list = ImmutableList.of(new MobSpawnerPhantom(), new MobSpawnerPatrol(), new MobSpawnerCat(), new VillageSiege(), new MobSpawnerTrader(iworlddataserver));
++            WorldDimension worlddimension = (WorldDimension) dimensions.getValue(dimensionKey);
++
++            org.bukkit.generator.WorldInfo worldInfo = new org.bukkit.craftbukkit.generator.CraftWorldInfo(iworlddataserver, worldSession, org.bukkit.World.Environment.getEnvironment(dimension), worlddimension.type().value());
++            if (biomeProvider == null && gen != null) {
++                biomeProvider = gen.getDefaultBiomeProvider(worldInfo);
++            }
++
++            ResourceKey<World> worldKey = ResourceKey.create(Registries.DIMENSION, dimensionKey.location());
++
++            if (dimensionKey == WorldDimension.OVERWORLD) {
++                this.worldData = worlddata;
++                this.worldData.setGameType(((DedicatedServer) this).getProperties().gamemode); // From DedicatedServer.init
++
++                WorldLoadListener worldloadlistener = this.progressListenerFactory.create(this.worldData.getGameRules().getInt(GameRules.RULE_SPAWN_CHUNK_RADIUS));
++
++                world = new WorldServer(this, this.executor, worldSession, iworlddataserver, worldKey, worlddimension, worldloadlistener, flag, j, list, true, (RandomSequences) null, org.bukkit.World.Environment.getEnvironment(dimension), gen, biomeProvider);
++                WorldPersistentData worldpersistentdata = world.getDataStorage();
++                this.readScoreboard(worldpersistentdata);
++                this.server.scoreboardManager = new org.bukkit.craftbukkit.scoreboard.CraftScoreboardManager(this, world.getScoreboard());
++                this.commandStorage = new PersistentCommandStorage(worldpersistentdata);
++            } else {
++                WorldLoadListener worldloadlistener = this.progressListenerFactory.create(worldData.getGameRules().getInt(GameRules.RULE_SPAWN_CHUNK_RADIUS));
++                world = new WorldServer(this, this.executor, worldSession, iworlddataserver, worldKey, worlddimension, worldloadlistener, flag, j, ImmutableList.of(), true, this.overworld().getRandomSequences(), org.bukkit.World.Environment.getEnvironment(dimension), gen, biomeProvider);
++            }
++
++            worlddata.setModdedInfo(this.getServerModName(), this.getModdedStatus().shouldReportAsModified());
++            this.initWorld(world, worlddata, worldData, worldoptions);
++
++            this.addLevel(world);
++            this.getPlayerList().addWorldborderListener(world);
++
++            if (worlddata.getCustomBossEvents() != null) {
++                this.getCustomBossEvents().load(worlddata.getCustomBossEvents(), this.registryAccess());
++            }
++        }
++        this.forceDifficulty();
++        for (WorldServer worldserver : this.getAllLevels()) {
++            this.prepareLevels(worldserver.getChunkSource().chunkMap.progressListener, worldserver);
++            worldserver.entityManager.tick(); // SPIGOT-6526: Load pending entities so they are available to the API
++            this.server.getPluginManager().callEvent(new org.bukkit.event.world.WorldLoadEvent(worldserver.getWorld()));
++        }
++
++        this.server.enablePlugins(org.bukkit.plugin.PluginLoadOrder.POSTWORLD);
++        this.server.getPluginManager().callEvent(new ServerLoadEvent(ServerLoadEvent.LoadType.STARTUP));
++        this.connection.acceptConnections();
++    }
++
++    public void initWorld(WorldServer worldserver, IWorldDataServer iworlddataserver, SaveData saveData, WorldOptions worldoptions) {
++        boolean flag = saveData.isDebugWorld();
++        // CraftBukkit start
++        if (worldserver.generator != null) {
++            worldserver.getWorld().getPopulators().addAll(worldserver.generator.getDefaultPopulators(worldserver.getWorld()));
++        }
+         WorldBorder worldborder = worldserver.getWorldBorder();
++        worldborder.applySettings(iworlddataserver.getWorldBorder()); // CraftBukkit - move up so that WorldBorder is set during WorldInitEvent
++        this.server.getPluginManager().callEvent(new org.bukkit.event.world.WorldInitEvent(worldserver.getWorld())); // CraftBukkit - SPIGOT-5569: Call WorldInitEvent before any chunks are generated
+ 
+         if (!iworlddataserver.isInitialized()) {
+             try {
+@@ -427,30 +682,8 @@
+             iworlddataserver.setInitialized(true);
+         }
+ 
+-        this.getPlayerList().addWorldborderListener(worldserver);
+-        if (this.worldData.getCustomBossEvents() != null) {
+-            this.getCustomBossEvents().load(this.worldData.getCustomBossEvents(), this.registryAccess());
+-        }
+-
+-        RandomSequences randomsequences = worldserver.getRandomSequences();
+-        Iterator iterator = iregistry.entrySet().iterator();
+-
+-        while (iterator.hasNext()) {
+-            Entry<ResourceKey<WorldDimension>, WorldDimension> entry = (Entry) iterator.next();
+-            ResourceKey<WorldDimension> resourcekey = (ResourceKey) entry.getKey();
+-
+-            if (resourcekey != WorldDimension.OVERWORLD) {
+-                ResourceKey<World> resourcekey1 = ResourceKey.create(Registries.DIMENSION, resourcekey.location());
+-                SecondaryWorldData secondaryworlddata = new SecondaryWorldData(this.worldData, iworlddataserver);
+-                WorldServer worldserver1 = new WorldServer(this, this.executor, this.storageSource, secondaryworlddata, resourcekey1, (WorldDimension) entry.getValue(), worldloadlistener, flag, j, ImmutableList.of(), false, randomsequences);
+-
+-                worldborder.addListener(new IWorldBorderListener.a(worldserver1.getWorldBorder()));
+-                this.levels.put(resourcekey1, worldserver1);
+-            }
+-        }
+-
+-        worldborder.applySettings(iworlddataserver.getWorldBorder());
+     }
++    // CraftBukkit end
+ 
+     private static void setInitialSpawn(WorldServer worldserver, IWorldDataServer iworlddataserver, boolean flag, boolean flag1) {
+         if (flag1) {
+@@ -458,6 +691,21 @@
+         } else {
+             ChunkProviderServer chunkproviderserver = worldserver.getChunkSource();
+             ChunkCoordIntPair chunkcoordintpair = new ChunkCoordIntPair(chunkproviderserver.randomState().sampler().findSpawnPosition());
++            // CraftBukkit start
++            if (worldserver.generator != null) {
++                Random rand = new Random(worldserver.getSeed());
++                org.bukkit.Location spawn = worldserver.generator.getFixedSpawnLocation(worldserver.getWorld(), rand);
++
++                if (spawn != null) {
++                    if (spawn.getWorld() != worldserver.getWorld()) {
++                        throw new IllegalStateException("Cannot set spawn point for " + iworlddataserver.getLevelName() + " to be in another world (" + spawn.getWorld().getName() + ")");
++                    } else {
++                        iworlddataserver.setSpawn(new BlockPosition(spawn.getBlockX(), spawn.getBlockY(), spawn.getBlockZ()), spawn.getYaw());
++                        return;
++                    }
++                }
++            }
++            // CraftBukkit end
+             int i = chunkproviderserver.getGenerator().getSpawnHeight(worldserver);
+ 
+             if (i < worldserver.getMinY()) {
+@@ -516,8 +764,11 @@
+         iworlddataserver.setGameType(EnumGamemode.SPECTATOR);
+     }
+ 
+-    public void prepareLevels(WorldLoadListener worldloadlistener) {
+-        WorldServer worldserver = this.overworld();
++    // CraftBukkit start
++    public void prepareLevels(WorldLoadListener worldloadlistener, WorldServer worldserver) {
++        // WorldServer worldserver = this.overworld();
++        this.forceTicks = true;
++        // CraftBukkit end
+ 
+         MinecraftServer.LOGGER.info("Preparing start region for dimension {}", worldserver.dimension().location());
+         BlockPosition blockposition = worldserver.getSharedSpawnPos();
+@@ -527,20 +778,22 @@
+ 
+         this.nextTickTimeNanos = SystemUtils.getNanos();
+         worldserver.setDefaultSpawnPos(blockposition, worldserver.getSharedSpawnAngle());
+-        int i = this.getGameRules().getInt(GameRules.RULE_SPAWN_CHUNK_RADIUS);
++        int i = worldserver.getGameRules().getInt(GameRules.RULE_SPAWN_CHUNK_RADIUS); // CraftBukkit - per-world
+         int j = i > 0 ? MathHelper.square(WorldLoadListener.calculateDiameter(i)) : 0;
+ 
+         while (chunkproviderserver.getTickingGenerated() < j) {
+-            this.nextTickTimeNanos = SystemUtils.getNanos() + MinecraftServer.PREPARE_LEVELS_DEFAULT_DELAY_NANOS;
+-            this.waitUntilNextTick();
++            // CraftBukkit start
++            // this.nextTickTimeNanos = SystemUtils.getNanos() + MinecraftServer.PREPARE_LEVELS_DEFAULT_DELAY_NANOS;
++            this.executeModerately();
+         }
+ 
+-        this.nextTickTimeNanos = SystemUtils.getNanos() + MinecraftServer.PREPARE_LEVELS_DEFAULT_DELAY_NANOS;
+-        this.waitUntilNextTick();
+-        Iterator iterator = this.levels.values().iterator();
++        // this.nextTickTimeNanos = SystemUtils.getNanos() + MinecraftServer.PREPARE_LEVELS_DEFAULT_DELAY_NANOS;
++        this.executeModerately();
++        // Iterator iterator = this.levels.values().iterator();
+ 
+-        while (iterator.hasNext()) {
+-            WorldServer worldserver1 = (WorldServer) iterator.next();
++        if (true) {
++            WorldServer worldserver1 = worldserver;
++            // CraftBukkit end
+             ForcedChunk forcedchunk = (ForcedChunk) worldserver1.getDataStorage().get(ForcedChunk.factory(), "chunks");
+ 
+             if (forcedchunk != null) {
+@@ -555,10 +808,17 @@
+             }
+         }
+ 
+-        this.nextTickTimeNanos = SystemUtils.getNanos() + MinecraftServer.PREPARE_LEVELS_DEFAULT_DELAY_NANOS;
+-        this.waitUntilNextTick();
++        // CraftBukkit start
++        // this.nextTickTimeNanos = SystemUtils.getNanos() + MinecraftServer.PREPARE_LEVELS_DEFAULT_DELAY_NANOS;
++        this.executeModerately();
++        // CraftBukkit end
+         worldloadlistener.stop();
+-        this.updateMobSpawningFlags();
++        // CraftBukkit start
++        // this.updateMobSpawningFlags();
++        worldserver.setSpawnSettings(this.isSpawningMonsters());
++
++        this.forceTicks = false;
++        // CraftBukkit end
+     }
+ 
+     public EnumGamemode getDefaultGameType() {
+@@ -588,12 +848,16 @@
+             worldserver.save((IProgressUpdate) null, flag1, worldserver.noSave && !flag2);
+         }
+ 
++        // CraftBukkit start - moved to WorldServer.save
++        /*
+         WorldServer worldserver1 = this.overworld();
+         IWorldDataServer iworlddataserver = this.worldData.overworldData();
+ 
+         iworlddataserver.setWorldBorder(worldserver1.getWorldBorder().createSettings());
+         this.worldData.setCustomBossEvents(this.getCustomBossEvents().save(this.registryAccess()));
+         this.storageSource.saveDataTag(this.registryAccess(), this.worldData, this.getPlayerList().getSingleplayerData());
++        */
++        // CraftBukkit end
+         if (flag1) {
+             Iterator iterator1 = this.getAllLevels().iterator();
+ 
+@@ -628,18 +892,40 @@
+         this.stopServer();
+     }
+ 
++    // CraftBukkit start
++    private boolean hasStopped = false;
++    private final Object stopLock = new Object();
++    public final boolean hasStopped() {
++        synchronized (stopLock) {
++            return hasStopped;
++        }
++    }
++    // CraftBukkit end
++
+     public void stopServer() {
++        // CraftBukkit start - prevent double stopping on multiple threads
++        synchronized(stopLock) {
++            if (hasStopped) return;
++            hasStopped = true;
++        }
++        // CraftBukkit end
+         if (this.metricsRecorder.isRecording()) {
+             this.cancelRecordingMetrics();
+         }
+ 
+         MinecraftServer.LOGGER.info("Stopping server");
++        // CraftBukkit start
++        if (this.server != null) {
++            this.server.disablePlugins();
++        }
++        // CraftBukkit end
+         this.getConnection().stop();
+         this.isSaving = true;
+         if (this.playerList != null) {
+             MinecraftServer.LOGGER.info("Saving players");
+             this.playerList.saveAll();
+             this.playerList.removeAll();
++            try { Thread.sleep(100); } catch (InterruptedException ex) {} // CraftBukkit - SPIGOT-625 - give server at least a chance to send packets
+         }
+ 
+         MinecraftServer.LOGGER.info("Saving worlds");
+@@ -727,7 +1013,7 @@
+             }
+ 
+             this.nextTickTimeNanos = SystemUtils.getNanos();
+-            this.statusIcon = (ServerPing.a) this.loadStatusIcon().orElse((Object) null);
++            this.statusIcon = (ServerPing.a) this.loadStatusIcon().orElse(null); // CraftBukkit - decompile error
+             this.status = this.buildServerStatus();
+ 
+             while (this.running) {
+@@ -744,6 +1030,7 @@
+                     if (j > MinecraftServer.OVERLOADED_THRESHOLD_NANOS + 20L * i && this.nextTickTimeNanos - this.lastOverloadWarningNanos >= MinecraftServer.OVERLOADED_WARNING_INTERVAL_NANOS + 100L * i) {
+                         long k = j / i;
+ 
++                        if (server.getWarnOnOverload()) // CraftBukkit
+                         MinecraftServer.LOGGER.warn("Can't keep up! Is the server overloaded? Running {}ms or {} ticks behind", j / TimeRange.NANOSECONDS_PER_MILLISECOND, k);
+                         this.nextTickTimeNanos += k * i;
+                         this.lastOverloadWarningNanos = this.nextTickTimeNanos;
+@@ -757,6 +1044,7 @@
+                     this.debugCommandProfiler = new MinecraftServer.TimeProfiler(SystemUtils.getNanos(), this.tickCount);
+                 }
+ 
++                MinecraftServer.currentTick = (int) (System.currentTimeMillis() / 50); // CraftBukkit
+                 this.nextTickTimeNanos += i;
+ 
+                 try {
+@@ -830,6 +1118,12 @@
+                     this.services.profileCache().clearExecutor();
+                 }
+ 
++                // CraftBukkit start - Restore terminal to original settings
++                try {
++                    reader.getTerminal().restore();
++                } catch (Exception ignored) {
++                }
++                // CraftBukkit end
+                 this.onServerExit();
+             }
+ 
+@@ -889,7 +1183,14 @@
+     }
+ 
+     private boolean haveTime() {
+-        return this.runningTask() || SystemUtils.getNanos() < (this.mayHaveDelayedTasks ? this.delayedTasksMaxNextTickTimeNanos : this.nextTickTimeNanos);
++        // CraftBukkit start
++        return this.forceTicks || this.runningTask() || SystemUtils.getNanos() < (this.mayHaveDelayedTasks ? this.delayedTasksMaxNextTickTimeNanos : this.nextTickTimeNanos);
++    }
++
++    private void executeModerately() {
++        this.runAllTasks();
++        java.util.concurrent.locks.LockSupport.parkNanos("executing tasks", 1000L);
++        // CraftBukkit end
+     }
+ 
+     public static boolean throwIfFatalException() {
+@@ -903,7 +1204,7 @@
+     }
+ 
+     public static void setFatalException(RuntimeException runtimeexception) {
+-        MinecraftServer.fatalException.compareAndSet((Object) null, runtimeexception);
++        MinecraftServer.fatalException.compareAndSet(null, runtimeexception); // CraftBukkit - decompile error
+     }
+ 
+     @Override
+@@ -977,7 +1278,7 @@
+         }
+     }
+ 
+-    protected void doRunTask(TickTask ticktask) {
++    public void doRunTask(TickTask ticktask) { // CraftBukkit - decompile error
+         Profiler.get().incrementCounter("runTask");
+         super.doRunTask(ticktask);
+     }
+@@ -1041,6 +1342,7 @@
+                     this.autoSave();
+                 }
+ 
++                this.server.getScheduler().mainThreadHeartbeat(); // CraftBukkit
+                 this.tickConnection();
+                 return;
+             }
+@@ -1055,7 +1357,7 @@
+         }
+ 
+         --this.ticksUntilAutosave;
+-        if (this.ticksUntilAutosave <= 0) {
++        if (this.autosavePeriod > 0 && this.ticksUntilAutosave <= 0) { // CraftBukkit
+             this.autoSave();
+         }
+ 
+@@ -1074,7 +1376,7 @@
+     }
+ 
+     private void autoSave() {
+-        this.ticksUntilAutosave = this.computeNextAutosaveInterval();
++        this.ticksUntilAutosave = this.autosavePeriod; // CraftBukkit
+         MinecraftServer.LOGGER.debug("Autosave started");
+         GameProfilerFiller gameprofilerfiller = Profiler.get();
+ 
+@@ -1154,11 +1456,26 @@
+         this.getPlayerList().getPlayers().forEach((entityplayer) -> {
+             entityplayer.connection.suspendFlushing();
+         });
++        this.server.getScheduler().mainThreadHeartbeat(); // CraftBukkit
+         gameprofilerfiller.push("commandFunctions");
+         this.getFunctions().tick();
+         gameprofilerfiller.popPush("levels");
+         Iterator iterator = this.getAllLevels().iterator();
+ 
++        // CraftBukkit start
++        // Run tasks that are waiting on processing
++        while (!processQueue.isEmpty()) {
++            processQueue.remove().run();
++        }
++
++        // Send time updates to everyone, it will get the right time from the world the player is in.
++        if (this.tickCount % 20 == 0) {
++            for (int i = 0; i < this.getPlayerList().players.size(); ++i) {
++                EntityPlayer entityplayer = (EntityPlayer) this.getPlayerList().players.get(i);
++                entityplayer.connection.send(new PacketPlayOutUpdateTime(entityplayer.level().getGameTime(), entityplayer.getPlayerTime(), entityplayer.serverLevel().getGameRules().getBoolean(GameRules.RULE_DAYLIGHT))); // Add support for per player time
++            }
++        }
++
+         while (iterator.hasNext()) {
+             WorldServer worldserver = (WorldServer) iterator.next();
+ 
+@@ -1167,11 +1484,13 @@
+ 
+                 return s + " " + String.valueOf(worldserver.dimension().location());
+             });
++            /* Drop global time updates
+             if (this.tickCount % 20 == 0) {
+                 gameprofilerfiller.push("timeSync");
+                 this.synchronizeTime(worldserver);
+                 gameprofilerfiller.pop();
+             }
++            // CraftBukkit end */
+ 
+             gameprofilerfiller.push("tick");
+ 
+@@ -1267,6 +1586,22 @@
+         return (WorldServer) this.levels.get(resourcekey);
+     }
+ 
++    // CraftBukkit start
++    public void addLevel(WorldServer level) {
++        Map<ResourceKey<World>, WorldServer> oldLevels = this.levels;
++        Map<ResourceKey<World>, WorldServer> newLevels = Maps.newLinkedHashMap(oldLevels);
++        newLevels.put(level.dimension(), level);
++        this.levels = Collections.unmodifiableMap(newLevels);
++    }
++
++    public void removeLevel(WorldServer level) {
++        Map<ResourceKey<World>, WorldServer> oldLevels = this.levels;
++        Map<ResourceKey<World>, WorldServer> newLevels = Maps.newLinkedHashMap(oldLevels);
++        newLevels.remove(level.dimension());
++        this.levels = Collections.unmodifiableMap(newLevels);
++    }
++    // CraftBukkit end
++
+     public Set<ResourceKey<World>> levelKeys() {
+         return this.levels.keySet();
+     }
+@@ -1296,7 +1631,7 @@
+ 
+     @DontObfuscate
+     public String getServerModName() {
+-        return "vanilla";
++        return server.getName(); // CraftBukkit - cb > vanilla!
+     }
+ 
+     public SystemReport fillSystemReport(SystemReport systemreport) {
+@@ -1634,11 +1969,11 @@
+ 
+     public CompletableFuture<Void> reloadResources(Collection<String> collection) {
+         CompletableFuture<Void> completablefuture = CompletableFuture.supplyAsync(() -> {
+-            Stream stream = collection.stream();
++            Stream<String> stream = collection.stream(); // CraftBukkit - decompile error
+             ResourcePackRepository resourcepackrepository = this.packRepository;
+ 
+             Objects.requireNonNull(this.packRepository);
+-            return (ImmutableList) stream.map(resourcepackrepository::getPack).filter(Objects::nonNull).map(ResourcePackLoader::open).collect(ImmutableList.toImmutableList());
++            return stream.map(resourcepackrepository::getPack).filter(Objects::nonNull).map(ResourcePackLoader::open).collect(ImmutableList.toImmutableList()); // CraftBukkit - decompile error
+         }, this).thenCompose((immutablelist) -> {
+             ResourceManager resourcemanager = new ResourceManager(EnumResourcePackType.SERVER_DATA, immutablelist);
+             List<IRegistry.a<?>> list = TagDataPack.loadTagsForExistingRegistries(resourcemanager, this.registries.compositeAccess());
+@@ -1654,6 +1989,7 @@
+         }).thenAcceptAsync((minecraftserver_reloadableresources) -> {
+             this.resources.close();
+             this.resources = minecraftserver_reloadableresources;
++            this.server.syncCommands(); // SPIGOT-5884: Lost on reload
+             this.packRepository.setSelected(collection);
+             WorldDataConfiguration worlddataconfiguration = new WorldDataConfiguration(getSelectedPacks(this.packRepository, true), this.worldData.enabledFeatures());
+ 
+@@ -1952,7 +2288,7 @@
+             final List<String> list = Lists.newArrayList();
+             final GameRules gamerules = this.getGameRules();
+ 
+-            gamerules.visitGameRuleTypes(new GameRules.GameRuleVisitor(this) {
++            gamerules.visitGameRuleTypes(new GameRules.GameRuleVisitor() { // CraftBukkit - decompile error
+                 @Override
+                 public <T extends GameRules.GameRuleValue<T>> void visit(GameRules.GameRuleKey<T> gamerules_gamerulekey, GameRules.GameRuleDefinition<T> gamerules_gameruledefinition) {
+                     list.add(String.format(Locale.ROOT, "%s=%s\n", gamerules_gamerulekey.getId(), gamerules.getRule(gamerules_gamerulekey)));
+@@ -2058,7 +2394,7 @@
+             try {
+                 label51:
+                 {
+-                    ArrayList arraylist;
++                    ArrayList<NativeModuleLister.a> arraylist; // CraftBukkit - decompile error
+ 
+                     try {
+                         arraylist = Lists.newArrayList(NativeModuleLister.listModules());
+@@ -2108,6 +2444,22 @@
+ 
+     }
+ 
++    // CraftBukkit start
++    public boolean isDebugging() {
++        return false;
++    }
++
++    @Deprecated
++    public static MinecraftServer getServer() {
++        return (Bukkit.getServer() instanceof CraftServer) ? ((CraftServer) Bukkit.getServer()).getServer() : null;
++    }
++
++    @Deprecated
++    public static IRegistryCustom getDefaultRegistryAccess() {
++        return CraftRegistry.getMinecraftRegistry();
++    }
++    // CraftBukkit end
++
+     private GameProfilerFiller createProfiler() {
+         if (this.willStartRecordingMetrics) {
+             this.metricsRecorder = ActiveMetricsRecorder.createStarted(new ServerMetricsSamplersProvider(SystemUtils.timeSource, this.isDedicatedServer()), SystemUtils.timeSource, SystemUtils.ioPool(), new MetricsPersister("server"), this.onMetricsRecordingStopped, (path) -> {
+@@ -2235,6 +2587,11 @@
+ 
+     }
+ 
++    // CraftBukkit start
++    public final java.util.concurrent.ExecutorService chatExecutor = java.util.concurrent.Executors.newCachedThreadPool(
++            new com.google.common.util.concurrent.ThreadFactoryBuilder().setDaemon(true).setNameFormat("Async Chat Thread - #%d").build());
++    // CraftBukkit end
++
+     public ChatDecorator getChatDecorator() {
+         return ChatDecorator.PLAIN;
+     }

paper-server/patches/sources/net/minecraft/server/ScoreboardServer.patch

@@ -0,0 +1,132 @@
+--- a/net/minecraft/server/ScoreboardServer.java
++++ b/net/minecraft/server/ScoreboardServer.java
+@@ -42,7 +42,7 @@
+     protected void onScoreChanged(ScoreHolder scoreholder, ScoreboardObjective scoreboardobjective, ScoreboardScore scoreboardscore) {
+         super.onScoreChanged(scoreholder, scoreboardobjective, scoreboardscore);
+         if (this.trackedObjectives.contains(scoreboardobjective)) {
+-            this.server.getPlayerList().broadcastAll(new PacketPlayOutScoreboardScore(scoreholder.getScoreboardName(), scoreboardobjective.getName(), scoreboardscore.value(), Optional.ofNullable(scoreboardscore.display()), Optional.ofNullable(scoreboardscore.numberFormat())));
++            this.broadcastAll(new PacketPlayOutScoreboardScore(scoreholder.getScoreboardName(), scoreboardobjective.getName(), scoreboardscore.value(), Optional.ofNullable(scoreboardscore.display()), Optional.ofNullable(scoreboardscore.numberFormat()))); // CraftBukkit
+         }
+ 
+         this.setDirty();
+@@ -57,7 +57,7 @@
+     @Override
+     public void onPlayerRemoved(ScoreHolder scoreholder) {
+         super.onPlayerRemoved(scoreholder);
+-        this.server.getPlayerList().broadcastAll(new ClientboundResetScorePacket(scoreholder.getScoreboardName(), (String) null));
++        this.broadcastAll(new ClientboundResetScorePacket(scoreholder.getScoreboardName(), (String) null)); // CraftBukkit
+         this.setDirty();
+     }
+ 
+@@ -65,7 +65,7 @@
+     public void onPlayerScoreRemoved(ScoreHolder scoreholder, ScoreboardObjective scoreboardobjective) {
+         super.onPlayerScoreRemoved(scoreholder, scoreboardobjective);
+         if (this.trackedObjectives.contains(scoreboardobjective)) {
+-            this.server.getPlayerList().broadcastAll(new ClientboundResetScorePacket(scoreholder.getScoreboardName(), scoreboardobjective.getName()));
++            this.broadcastAll(new ClientboundResetScorePacket(scoreholder.getScoreboardName(), scoreboardobjective.getName())); // CraftBukkit
+         }
+ 
+         this.setDirty();
+@@ -78,7 +78,7 @@
+         super.setDisplayObjective(displayslot, scoreboardobjective);
+         if (scoreboardobjective1 != scoreboardobjective && scoreboardobjective1 != null) {
+             if (this.getObjectiveDisplaySlotCount(scoreboardobjective1) > 0) {
+-                this.server.getPlayerList().broadcastAll(new PacketPlayOutScoreboardDisplayObjective(displayslot, scoreboardobjective));
++                this.broadcastAll(new PacketPlayOutScoreboardDisplayObjective(displayslot, scoreboardobjective)); // CraftBukkit
+             } else {
+                 this.stopTrackingObjective(scoreboardobjective1);
+             }
+@@ -86,7 +86,7 @@
+ 
+         if (scoreboardobjective != null) {
+             if (this.trackedObjectives.contains(scoreboardobjective)) {
+-                this.server.getPlayerList().broadcastAll(new PacketPlayOutScoreboardDisplayObjective(displayslot, scoreboardobjective));
++                this.broadcastAll(new PacketPlayOutScoreboardDisplayObjective(displayslot, scoreboardobjective)); // CraftBukkit
+             } else {
+                 this.startTrackingObjective(scoreboardobjective);
+             }
+@@ -98,7 +98,7 @@
+     @Override
+     public boolean addPlayerToTeam(String s, ScoreboardTeam scoreboardteam) {
+         if (super.addPlayerToTeam(s, scoreboardteam)) {
+-            this.server.getPlayerList().broadcastAll(PacketPlayOutScoreboardTeam.createPlayerPacket(scoreboardteam, s, PacketPlayOutScoreboardTeam.a.ADD));
++            this.broadcastAll(PacketPlayOutScoreboardTeam.createPlayerPacket(scoreboardteam, s, PacketPlayOutScoreboardTeam.a.ADD)); // CraftBukkit
+             this.setDirty();
+             return true;
+         } else {
+@@ -109,7 +109,7 @@
+     @Override
+     public void removePlayerFromTeam(String s, ScoreboardTeam scoreboardteam) {
+         super.removePlayerFromTeam(s, scoreboardteam);
+-        this.server.getPlayerList().broadcastAll(PacketPlayOutScoreboardTeam.createPlayerPacket(scoreboardteam, s, PacketPlayOutScoreboardTeam.a.REMOVE));
++        this.broadcastAll(PacketPlayOutScoreboardTeam.createPlayerPacket(scoreboardteam, s, PacketPlayOutScoreboardTeam.a.REMOVE)); // CraftBukkit
+         this.setDirty();
+     }
+ 
+@@ -123,7 +123,7 @@
+     public void onObjectiveChanged(ScoreboardObjective scoreboardobjective) {
+         super.onObjectiveChanged(scoreboardobjective);
+         if (this.trackedObjectives.contains(scoreboardobjective)) {
+-            this.server.getPlayerList().broadcastAll(new PacketPlayOutScoreboardObjective(scoreboardobjective, 2));
++            this.broadcastAll(new PacketPlayOutScoreboardObjective(scoreboardobjective, 2)); // CraftBukkit
+         }
+ 
+         this.setDirty();
+@@ -142,21 +142,21 @@
+     @Override
+     public void onTeamAdded(ScoreboardTeam scoreboardteam) {
+         super.onTeamAdded(scoreboardteam);
+-        this.server.getPlayerList().broadcastAll(PacketPlayOutScoreboardTeam.createAddOrModifyPacket(scoreboardteam, true));
++        this.broadcastAll(PacketPlayOutScoreboardTeam.createAddOrModifyPacket(scoreboardteam, true)); // CraftBukkit
+         this.setDirty();
+     }
+ 
+     @Override
+     public void onTeamChanged(ScoreboardTeam scoreboardteam) {
+         super.onTeamChanged(scoreboardteam);
+-        this.server.getPlayerList().broadcastAll(PacketPlayOutScoreboardTeam.createAddOrModifyPacket(scoreboardteam, false));
++        this.broadcastAll(PacketPlayOutScoreboardTeam.createAddOrModifyPacket(scoreboardteam, false)); // CraftBukkit
+         this.setDirty();
+     }
+ 
+     @Override
+     public void onTeamRemoved(ScoreboardTeam scoreboardteam) {
+         super.onTeamRemoved(scoreboardteam);
+-        this.server.getPlayerList().broadcastAll(PacketPlayOutScoreboardTeam.createRemovePacket(scoreboardteam));
++        this.broadcastAll(PacketPlayOutScoreboardTeam.createRemovePacket(scoreboardteam)); // CraftBukkit
+         this.setDirty();
+     }
+ 
+@@ -207,6 +207,7 @@
+ 
+         while (iterator.hasNext()) {
+             EntityPlayer entityplayer = (EntityPlayer) iterator.next();
++            if (entityplayer.getBukkitEntity().getScoreboard().getHandle() != this) continue; // CraftBukkit - Only players on this board
+             Iterator iterator1 = list.iterator();
+ 
+             while (iterator1.hasNext()) {
+@@ -243,6 +244,7 @@
+ 
+         while (iterator.hasNext()) {
+             EntityPlayer entityplayer = (EntityPlayer) iterator.next();
++            if (entityplayer.getBukkitEntity().getScoreboard().getHandle() != this) continue; // CraftBukkit - Only players on this board
+             Iterator iterator1 = list.iterator();
+ 
+             while (iterator1.hasNext()) {
+@@ -287,6 +289,16 @@
+         return this.createData().load(nbttagcompound, holderlookup_a);
+     }
+ 
++    // CraftBukkit start - Send to players
++    private void broadcastAll(Packet packet) {
++        for (EntityPlayer entityplayer : (List<EntityPlayer>) this.server.getPlayerList().players) {
++            if (entityplayer.getBukkitEntity().getScoreboard().getHandle() == this) {
++                entityplayer.connection.send(packet);
++            }
++        }
++    }
++    // CraftBukkit end
++
+     public static enum Action {
+ 
+         CHANGE, REMOVE;

paper-server/patches/sources/net/minecraft/server/ServerTickRateManager.patch

@@ -0,0 +1,53 @@
+--- a/net/minecraft/server/ServerTickRateManager.java
++++ b/net/minecraft/server/ServerTickRateManager.java
+@@ -59,8 +59,14 @@
+     }
+ 
+     public boolean stopSprinting() {
++        // CraftBukkit start, add sendLog parameter
++        return stopSprinting(true);
++    }
++
++    public boolean stopSprinting(boolean sendLog) {
++        // CraftBukkit end
+         if (this.remainingSprintTicks > 0L) {
+-            this.finishTickSprint();
++            this.finishTickSprint(sendLog); // CraftBukkit - add sendLog parameter
+             return true;
+         } else {
+             return false;
+@@ -78,7 +84,7 @@
+         return flag;
+     }
+ 
+-    private void finishTickSprint() {
++    private void finishTickSprint(boolean sendLog) { // CraftBukkit - add sendLog parameter
+         long i = this.scheduledCurrentSprintTicks - this.remainingSprintTicks;
+         double d0 = Math.max(1.0D, (double) this.sprintTimeSpend) / (double) TimeRange.NANOSECONDS_PER_MILLISECOND;
+         int j = (int) ((double) (TimeRange.MILLISECONDS_PER_SECOND * i) / d0);
+@@ -86,9 +92,13 @@
+ 
+         this.scheduledCurrentSprintTicks = 0L;
+         this.sprintTimeSpend = 0L;
+-        this.server.createCommandSourceStack().sendSuccess(() -> {
+-            return IChatBaseComponent.translatable("commands.tick.sprint.report", j, s);
+-        }, true);
++        // CraftBukkit start - add sendLog parameter
++        if (sendLog) {
++            this.server.createCommandSourceStack().sendSuccess(() -> {
++                return IChatBaseComponent.translatable("commands.tick.sprint.report", j, s);
++            }, true);
++        }
++        // CraftBukkit end
+         this.remainingSprintTicks = 0L;
+         this.setFrozen(this.previousIsFrozen);
+         this.server.onTickRateChanged();
+@@ -102,7 +112,7 @@
+             --this.remainingSprintTicks;
+             return true;
+         } else {
+-            this.finishTickSprint();
++            this.finishTickSprint(true); // CraftBukkit - add sendLog parameter
+             return false;
+         }
+     }

paper-server/patches/sources/net/minecraft/server/bossevents/BossBattleCustom.patch

@@ -0,0 +1,30 @@
+--- a/net/minecraft/server/bossevents/BossBattleCustom.java
++++ b/net/minecraft/server/bossevents/BossBattleCustom.java
+@@ -19,12 +19,27 @@
+ import net.minecraft.util.MathHelper;
+ import net.minecraft.world.BossBattle;
+ 
++// CraftBukkit start
++import org.bukkit.boss.KeyedBossBar;
++import org.bukkit.craftbukkit.boss.CraftKeyedBossbar;
++// CraftBukkit end
++
+ public class BossBattleCustom extends BossBattleServer {
+ 
+     private final MinecraftKey id;
+     private final Set<UUID> players = Sets.newHashSet();
+     private int value;
+     private int max = 100;
++    // CraftBukkit start
++    private KeyedBossBar bossBar;
++
++    public KeyedBossBar getBukkitEntity() {
++        if (bossBar == null) {
++            bossBar = new CraftKeyedBossbar(this);
++        }
++        return bossBar;
++    }
++    // CraftBukkit end
+ 
+     public BossBattleCustom(MinecraftKey minecraftkey, IChatBaseComponent ichatbasecomponent) {
+         super(ichatbasecomponent, BossBattle.BarColor.WHITE, BossBattle.BarStyle.PROGRESS);

paper-server/patches/sources/net/minecraft/server/commands/CommandDifficulty.patch

@@ -0,0 +1,17 @@
+--- a/net/minecraft/server/commands/CommandDifficulty.java
++++ b/net/minecraft/server/commands/CommandDifficulty.java
+@@ -44,11 +44,12 @@
+ 
+     public static int setDifficulty(CommandListenerWrapper commandlistenerwrapper, EnumDifficulty enumdifficulty) throws CommandSyntaxException {
+         MinecraftServer minecraftserver = commandlistenerwrapper.getServer();
++        net.minecraft.server.level.WorldServer worldServer = commandlistenerwrapper.getLevel(); // CraftBukkit
+ 
+-        if (minecraftserver.getWorldData().getDifficulty() == enumdifficulty) {
++        if (worldServer.getDifficulty() == enumdifficulty) { // CraftBukkit
+             throw CommandDifficulty.ERROR_ALREADY_DIFFICULT.create(enumdifficulty.getKey());
+         } else {
+-            minecraftserver.setDifficulty(enumdifficulty, true);
++            worldServer.serverLevelData.setDifficulty(enumdifficulty); // CraftBukkit
+             commandlistenerwrapper.sendSuccess(() -> {
+                 return IChatBaseComponent.translatable("commands.difficulty.success", enumdifficulty.getDisplayName());
+             }, true);

paper-server/patches/sources/net/minecraft/server/commands/CommandEffect.patch

@@ -0,0 +1,29 @@
+--- a/net/minecraft/server/commands/CommandEffect.java
++++ b/net/minecraft/server/commands/CommandEffect.java
+@@ -84,7 +84,7 @@
+             if (entity instanceof EntityLiving) {
+                 MobEffect mobeffect = new MobEffect(holder, k, i, false, flag);
+ 
+-                if (((EntityLiving) entity).addEffect(mobeffect, commandlistenerwrapper.getEntity())) {
++                if (((EntityLiving) entity).addEffect(mobeffect, commandlistenerwrapper.getEntity(), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.COMMAND)) { // CraftBukkit
+                     ++j;
+                 }
+             }
+@@ -114,7 +114,7 @@
+         while (iterator.hasNext()) {
+             Entity entity = (Entity) iterator.next();
+ 
+-            if (entity instanceof EntityLiving && ((EntityLiving) entity).removeAllEffects()) {
++            if (entity instanceof EntityLiving && ((EntityLiving) entity).removeAllEffects(org.bukkit.event.entity.EntityPotionEffectEvent.Cause.COMMAND)) { // CraftBukkit
+                 ++i;
+             }
+         }
+@@ -144,7 +144,7 @@
+         while (iterator.hasNext()) {
+             Entity entity = (Entity) iterator.next();
+ 
+-            if (entity instanceof EntityLiving && ((EntityLiving) entity).removeEffect(holder)) {
++            if (entity instanceof EntityLiving && ((EntityLiving) entity).removeEffect(holder, org.bukkit.event.entity.EntityPotionEffectEvent.Cause.COMMAND)) { // CraftBukkit
+                 ++i;
+             }
+         }

paper-server/patches/sources/net/minecraft/server/commands/CommandGamerule.patch

@@ -0,0 +1,20 @@
+--- a/net/minecraft/server/commands/CommandGamerule.java
++++ b/net/minecraft/server/commands/CommandGamerule.java
+@@ -34,7 +34,7 @@
+ 
+     static <T extends GameRules.GameRuleValue<T>> int setRule(CommandContext<CommandListenerWrapper> commandcontext, GameRules.GameRuleKey<T> gamerules_gamerulekey) {
+         CommandListenerWrapper commandlistenerwrapper = (CommandListenerWrapper) commandcontext.getSource();
+-        T t0 = commandlistenerwrapper.getServer().getGameRules().getRule(gamerules_gamerulekey);
++        T t0 = commandlistenerwrapper.getLevel().getGameRules().getRule(gamerules_gamerulekey); // CraftBukkit
+ 
+         t0.setFromArgument(commandcontext, "value");
+         commandlistenerwrapper.sendSuccess(() -> {
+@@ -44,7 +44,7 @@
+     }
+ 
+     static <T extends GameRules.GameRuleValue<T>> int queryRule(CommandListenerWrapper commandlistenerwrapper, GameRules.GameRuleKey<T> gamerules_gamerulekey) {
+-        T t0 = commandlistenerwrapper.getServer().getGameRules().getRule(gamerules_gamerulekey);
++        T t0 = commandlistenerwrapper.getLevel().getGameRules().getRule(gamerules_gamerulekey); // CraftBukkit
+ 
+         commandlistenerwrapper.sendSuccess(() -> {
+             return IChatBaseComponent.translatable("commands.gamerule.query", gamerules_gamerulekey.getId(), t0.toString());

paper-server/patches/sources/net/minecraft/server/commands/CommandGive.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/server/commands/CommandGive.java
++++ b/net/minecraft/server/commands/CommandGive.java
+@@ -60,7 +60,7 @@
+                     EntityItem entityitem;
+ 
+                     if (flag && itemstack1.isEmpty()) {
+-                        entityitem = entityplayer.drop(itemstack, false);
++                        entityitem = entityplayer.drop(itemstack, false, false, false); // CraftBukkit - SPIGOT-2942: Add boolean to call event
+                         if (entityitem != null) {
+                             entityitem.makeFakeItem();
+                         }

paper-server/patches/sources/net/minecraft/server/commands/CommandList.patch

@@ -0,0 +1,18 @@
+--- a/net/minecraft/server/commands/CommandList.java
++++ b/net/minecraft/server/commands/CommandList.java
+@@ -35,7 +35,14 @@
+ 
+     private static int format(CommandListenerWrapper commandlistenerwrapper, Function<EntityPlayer, IChatBaseComponent> function) {
+         PlayerList playerlist = commandlistenerwrapper.getServer().getPlayerList();
+-        List<EntityPlayer> list = playerlist.getPlayers();
++        // CraftBukkit start
++        List<EntityPlayer> players = playerlist.getPlayers();
++        if (commandlistenerwrapper.getBukkitSender() instanceof org.bukkit.entity.Player) {
++            org.bukkit.entity.Player sender = (org.bukkit.entity.Player) commandlistenerwrapper.getBukkitSender();
++            players = players.stream().filter((ep) -> sender.canSee(ep.getBukkitEntity())).collect(java.util.stream.Collectors.toList());
++        }
++        List<EntityPlayer> list = players;
++        // CraftBukkit end
+         IChatBaseComponent ichatbasecomponent = ChatComponentUtils.formatList(list, function);
+ 
+         commandlistenerwrapper.sendSuccess(() -> {

paper-server/patches/sources/net/minecraft/server/commands/CommandLoot.patch

@@ -0,0 +1,19 @@
+--- a/net/minecraft/server/commands/CommandLoot.java
++++ b/net/minecraft/server/commands/CommandLoot.java
+@@ -95,7 +95,7 @@
+     }
+ 
+     private static <T extends ArgumentBuilder<CommandListenerWrapper, T>> T addTargets(T t0, CommandLoot.c commandloot_c) {
+-        return t0.then(((LiteralArgumentBuilder) net.minecraft.commands.CommandDispatcher.literal("replace").then(net.minecraft.commands.CommandDispatcher.literal("entity").then(net.minecraft.commands.CommandDispatcher.argument("entities", ArgumentEntity.entities()).then(commandloot_c.construct(net.minecraft.commands.CommandDispatcher.argument("slot", ArgumentInventorySlot.slot()), (commandcontext, list, commandloot_a) -> {
++        return (T) t0.then(((LiteralArgumentBuilder) net.minecraft.commands.CommandDispatcher.literal("replace").then(net.minecraft.commands.CommandDispatcher.literal("entity").then(net.minecraft.commands.CommandDispatcher.argument("entities", ArgumentEntity.entities()).then(commandloot_c.construct(net.minecraft.commands.CommandDispatcher.argument("slot", ArgumentInventorySlot.slot()), (commandcontext, list, commandloot_a) -> { // CraftBukkit - decompile error
+             return entityReplace(ArgumentEntity.getEntities(commandcontext, "entities"), ArgumentInventorySlot.getSlot(commandcontext, "slot"), list.size(), list, commandloot_a);
+         }).then(commandloot_c.construct(net.minecraft.commands.CommandDispatcher.argument("count", IntegerArgumentType.integer(0)), (commandcontext, list, commandloot_a) -> {
+             return entityReplace(ArgumentEntity.getEntities(commandcontext, "entities"), ArgumentInventorySlot.getSlot(commandcontext, "slot"), IntegerArgumentType.getInteger(commandcontext, "count"), list, commandloot_a);
+@@ -250,6 +250,7 @@
+     private static int dropInWorld(CommandListenerWrapper commandlistenerwrapper, Vec3D vec3d, List<ItemStack> list, CommandLoot.a commandloot_a) throws CommandSyntaxException {
+         WorldServer worldserver = commandlistenerwrapper.getLevel();
+ 
++        list.removeIf(ItemStack::isEmpty); // CraftBukkit - SPIGOT-6959 Remove empty items for avoid throw an error in new EntityItem
+         list.forEach((itemstack) -> {
+             EntityItem entityitem = new EntityItem(worldserver, vec3d.x, vec3d.y, vec3d.z, itemstack.copy());
+ 

paper-server/patches/sources/net/minecraft/server/commands/CommandReload.patch

@@ -0,0 +1,19 @@
+--- a/net/minecraft/server/commands/CommandReload.java
++++ b/net/minecraft/server/commands/CommandReload.java
+@@ -44,6 +44,16 @@
+         return collection1;
+     }
+ 
++    // CraftBukkit start
++    public static void reload(MinecraftServer minecraftserver) {
++        ResourcePackRepository resourcepackrepository = minecraftserver.getPackRepository();
++        SaveData savedata = minecraftserver.getWorldData();
++        Collection<String> collection = resourcepackrepository.getSelectedIds();
++        Collection<String> collection1 = discoverNewPacks(resourcepackrepository, savedata, collection);
++        minecraftserver.reloadResources(collection1);
++    }
++    // CraftBukkit end
++
+     public static void register(CommandDispatcher<CommandListenerWrapper> commanddispatcher) {
+         commanddispatcher.register((LiteralArgumentBuilder) ((LiteralArgumentBuilder) net.minecraft.commands.CommandDispatcher.literal("reload").requires((commandlistenerwrapper) -> {
+             return commandlistenerwrapper.hasPermission(2);

paper-server/patches/sources/net/minecraft/server/commands/CommandSchedule.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/server/commands/CommandSchedule.java
++++ b/net/minecraft/server/commands/CommandSchedule.java
+@@ -58,7 +58,7 @@
+         } else {
+             long j = commandlistenerwrapper.getLevel().getGameTime() + (long) i;
+             MinecraftKey minecraftkey = (MinecraftKey) pair.getFirst();
+-            CustomFunctionCallbackTimerQueue<MinecraftServer> customfunctioncallbacktimerqueue = commandlistenerwrapper.getServer().getWorldData().overworldData().getScheduledEvents();
++            CustomFunctionCallbackTimerQueue<MinecraftServer> customfunctioncallbacktimerqueue = commandlistenerwrapper.getLevel().serverLevelData.overworldData().getScheduledEvents(); // CraftBukkit - SPIGOT-6667: Use world specific function timer
+             Optional<net.minecraft.commands.functions.CommandFunction<CommandListenerWrapper>> optional = ((Either) pair.getSecond()).left();
+             String s;
+ 

paper-server/patches/sources/net/minecraft/server/commands/CommandSetWorldSpawn.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/server/commands/CommandSetWorldSpawn.java
++++ b/net/minecraft/server/commands/CommandSetWorldSpawn.java
+@@ -30,7 +30,7 @@
+     private static int setSpawn(CommandListenerWrapper commandlistenerwrapper, BlockPosition blockposition, float f) {
+         WorldServer worldserver = commandlistenerwrapper.getLevel();
+ 
+-        if (worldserver.dimension() != World.OVERWORLD) {
++        if (false && worldserver.dimension() != World.OVERWORLD) { // CraftBukkit - SPIGOT-7649: allow in all worlds
+             commandlistenerwrapper.sendFailure(IChatBaseComponent.translatable("commands.setworldspawn.failure.not_overworld"));
+             return 0;
+         } else {

paper-server/patches/sources/net/minecraft/server/commands/CommandSpawnpoint.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/server/commands/CommandSpawnpoint.java
++++ b/net/minecraft/server/commands/CommandSpawnpoint.java
+@@ -41,7 +41,7 @@
+         while (iterator.hasNext()) {
+             EntityPlayer entityplayer = (EntityPlayer) iterator.next();
+ 
+-            entityplayer.setRespawnPosition(resourcekey, blockposition, f, true, false);
++            entityplayer.setRespawnPosition(resourcekey, blockposition, f, true, false, org.bukkit.event.player.PlayerSpawnChangeEvent.Cause.COMMAND); // CraftBukkit
+         }
+ 
+         String s = resourcekey.location().toString();

paper-server/patches/sources/net/minecraft/server/commands/CommandSpreadPlayers.patch

@@ -0,0 +1,20 @@
+--- a/net/minecraft/server/commands/CommandSpreadPlayers.java
++++ b/net/minecraft/server/commands/CommandSpreadPlayers.java
+@@ -93,7 +93,7 @@
+             if (entity instanceof EntityHuman) {
+                 set.add(entity.getTeam());
+             } else {
+-                set.add((Object) null);
++                set.add((ScoreboardTeamBase) null); // CraftBukkit - decompile error
+             }
+         }
+ 
+@@ -203,7 +203,7 @@
+                 commandspreadplayers_a = acommandspreadplayers_a[j++];
+             }
+ 
+-            entity.teleportTo(worldserver, (double) MathHelper.floor(commandspreadplayers_a.x) + 0.5D, (double) commandspreadplayers_a.getSpawnY(worldserver, i), (double) MathHelper.floor(commandspreadplayers_a.z) + 0.5D, Set.of(), entity.getYRot(), entity.getXRot(), true);
++            entity.teleportTo(worldserver, (double) MathHelper.floor(commandspreadplayers_a.x) + 0.5D, (double) commandspreadplayers_a.getSpawnY(worldserver, i), (double) MathHelper.floor(commandspreadplayers_a.z) + 0.5D, Set.of(), entity.getYRot(), entity.getXRot(), true, org.bukkit.event.player.PlayerTeleportEvent.TeleportCause.COMMAND); // CraftBukkit - handle teleport reason
+             d1 = Double.MAX_VALUE;
+             CommandSpreadPlayers.a[] acommandspreadplayers_a1 = acommandspreadplayers_a;
+             int k = acommandspreadplayers_a.length;

paper-server/patches/sources/net/minecraft/server/commands/CommandSummon.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/server/commands/CommandSummon.java
++++ b/net/minecraft/server/commands/CommandSummon.java
+@@ -67,7 +67,7 @@
+                     ((EntityInsentient) entity).finalizeSpawn(commandlistenerwrapper.getLevel(), commandlistenerwrapper.getLevel().getCurrentDifficultyAt(entity.blockPosition()), EntitySpawnReason.COMMAND, (GroupDataEntity) null);
+                 }
+ 
+-                if (!worldserver.tryAddFreshEntityWithPassengers(entity)) {
++                if (!worldserver.tryAddFreshEntityWithPassengers(entity, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.COMMAND)) { // CraftBukkit - pass a spawn reason of "COMMAND"
+                     throw CommandSummon.ERROR_DUPLICATE_UUID.create();
+                 } else {
+                     return entity;

paper-server/patches/sources/net/minecraft/server/commands/CommandTeleport.patch

@@ -0,0 +1,49 @@
+--- a/net/minecraft/server/commands/CommandTeleport.java
++++ b/net/minecraft/server/commands/CommandTeleport.java
+@@ -31,6 +31,14 @@
+ import net.minecraft.world.phys.Vec2F;
+ import net.minecraft.world.phys.Vec3D;
+ 
++// CraftBukkit start
++import net.minecraft.server.level.EntityPlayer;
++import org.bukkit.Location;
++import org.bukkit.craftbukkit.CraftWorld;
++import org.bukkit.event.entity.EntityTeleportEvent;
++import org.bukkit.event.player.PlayerTeleportEvent;
++// CraftBukkit end
++
+ public class CommandTeleport {
+ 
+     private static final SimpleCommandExceptionType INVALID_POSITION = new SimpleCommandExceptionType(IChatBaseComponent.translatable("commands.teleport.invalidPosition"));
+@@ -167,7 +175,30 @@
+             float f4 = MathHelper.wrapDegrees(f2);
+             float f5 = MathHelper.wrapDegrees(f3);
+ 
+-            if (entity.teleportTo(worldserver, d3, d4, d5, set, f4, f5, true)) {
++            // CraftBukkit start - Teleport event
++            boolean result;
++            if (entity instanceof EntityPlayer player) {
++                result = player.teleportTo(worldserver, d3, d4, d5, set, f4, f5, true, PlayerTeleportEvent.TeleportCause.COMMAND);
++            } else {
++                Location to = new Location(worldserver.getWorld(), d3, d4, d5, f4, f5);
++                EntityTeleportEvent event = new EntityTeleportEvent(entity.getBukkitEntity(), entity.getBukkitEntity().getLocation(), to);
++                worldserver.getCraftServer().getPluginManager().callEvent(event);
++                if (event.isCancelled()) {
++                    return;
++                }
++
++                d3 = to.getX();
++                d4 = to.getY();
++                d5 = to.getZ();
++                f4 = to.getYaw();
++                f5 = to.getPitch();
++                worldserver = ((CraftWorld) to.getWorld()).getHandle();
++
++                result = entity.teleportTo(worldserver, d3, d4, d5, set, f4, f5, true);
++            }
++
++            if (result) {
++                // CraftBukkit end
+                 if (lookat != null) {
+                     lookat.perform(commandlistenerwrapper, entity);
+                 }

paper-server/patches/sources/net/minecraft/server/commands/CommandTime.patch

@@ -0,0 +1,56 @@
+--- a/net/minecraft/server/commands/CommandTime.java
++++ b/net/minecraft/server/commands/CommandTime.java
+@@ -9,6 +9,11 @@
+ import net.minecraft.network.chat.IChatBaseComponent;
+ import net.minecraft.server.level.WorldServer;
+ 
++// CraftBukkit start
++import org.bukkit.Bukkit;
++import org.bukkit.event.world.TimeSkipEvent;
++// CraftBukkit end
++
+ public class CommandTime {
+ 
+     public CommandTime() {}
+@@ -49,12 +54,18 @@
+     }
+ 
+     public static int setTime(CommandListenerWrapper commandlistenerwrapper, int i) {
+-        Iterator iterator = commandlistenerwrapper.getServer().getAllLevels().iterator();
++        Iterator iterator = com.google.common.collect.Iterators.singletonIterator(commandlistenerwrapper.getLevel()); // CraftBukkit - SPIGOT-6496: Only set the time for the world the command originates in
+ 
+         while (iterator.hasNext()) {
+             WorldServer worldserver = (WorldServer) iterator.next();
+ 
+-            worldserver.setDayTime((long) i);
++            // CraftBukkit start
++            TimeSkipEvent event = new TimeSkipEvent(worldserver.getWorld(), TimeSkipEvent.SkipReason.COMMAND, i - worldserver.getDayTime());
++            Bukkit.getPluginManager().callEvent(event);
++            if (!event.isCancelled()) {
++                worldserver.setDayTime((long) worldserver.getDayTime() + event.getSkipAmount());
++            }
++            // CraftBukkit end
+         }
+ 
+         commandlistenerwrapper.getServer().forceTimeSynchronization();
+@@ -65,12 +76,18 @@
+     }
+ 
+     public static int addTime(CommandListenerWrapper commandlistenerwrapper, int i) {
+-        Iterator iterator = commandlistenerwrapper.getServer().getAllLevels().iterator();
++        Iterator iterator = com.google.common.collect.Iterators.singletonIterator(commandlistenerwrapper.getLevel()); // CraftBukkit - SPIGOT-6496: Only set the time for the world the command originates in
+ 
+         while (iterator.hasNext()) {
+             WorldServer worldserver = (WorldServer) iterator.next();
+ 
+-            worldserver.setDayTime(worldserver.getDayTime() + (long) i);
++            // CraftBukkit start
++            TimeSkipEvent event = new TimeSkipEvent(worldserver.getWorld(), TimeSkipEvent.SkipReason.COMMAND, i);
++            Bukkit.getPluginManager().callEvent(event);
++            if (!event.isCancelled()) {
++                worldserver.setDayTime(worldserver.getDayTime() + event.getSkipAmount());
++            }
++            // CraftBukkit end
+         }
+ 
+         commandlistenerwrapper.getServer().forceTimeSynchronization();

paper-server/patches/sources/net/minecraft/server/commands/CommandWeather.patch

@@ -0,0 +1,34 @@
+--- a/net/minecraft/server/commands/CommandWeather.java
++++ b/net/minecraft/server/commands/CommandWeather.java
+@@ -34,11 +34,11 @@
+     }
+ 
+     private static int getDuration(CommandListenerWrapper commandlistenerwrapper, int i, IntProvider intprovider) {
+-        return i == -1 ? intprovider.sample(commandlistenerwrapper.getServer().overworld().getRandom()) : i;
++        return i == -1 ? intprovider.sample(commandlistenerwrapper.getLevel().getRandom()) : i; // CraftBukkit - SPIGOT-7680: per-world
+     }
+ 
+     private static int setClear(CommandListenerWrapper commandlistenerwrapper, int i) {
+-        commandlistenerwrapper.getServer().overworld().setWeatherParameters(getDuration(commandlistenerwrapper, i, WorldServer.RAIN_DELAY), 0, false, false);
++        commandlistenerwrapper.getLevel().setWeatherParameters(getDuration(commandlistenerwrapper, i, WorldServer.RAIN_DELAY), 0, false, false); // CraftBukkit - SPIGOT-7680: per-world
+         commandlistenerwrapper.sendSuccess(() -> {
+             return IChatBaseComponent.translatable("commands.weather.set.clear");
+         }, true);
+@@ -46,7 +46,7 @@
+     }
+ 
+     private static int setRain(CommandListenerWrapper commandlistenerwrapper, int i) {
+-        commandlistenerwrapper.getServer().overworld().setWeatherParameters(0, getDuration(commandlistenerwrapper, i, WorldServer.RAIN_DURATION), true, false);
++        commandlistenerwrapper.getLevel().setWeatherParameters(0, getDuration(commandlistenerwrapper, i, WorldServer.RAIN_DURATION), true, false); // CraftBukkit - SPIGOT-7680: per-world
+         commandlistenerwrapper.sendSuccess(() -> {
+             return IChatBaseComponent.translatable("commands.weather.set.rain");
+         }, true);
+@@ -54,7 +54,7 @@
+     }
+ 
+     private static int setThunder(CommandListenerWrapper commandlistenerwrapper, int i) {
+-        commandlistenerwrapper.getServer().overworld().setWeatherParameters(0, getDuration(commandlistenerwrapper, i, WorldServer.THUNDER_DURATION), true, true);
++        commandlistenerwrapper.getLevel().setWeatherParameters(0, getDuration(commandlistenerwrapper, i, WorldServer.THUNDER_DURATION), true, true); // CraftBukkit - SPIGOT-7680: per-world
+         commandlistenerwrapper.sendSuccess(() -> {
+             return IChatBaseComponent.translatable("commands.weather.set.thunder");
+         }, true);

paper-server/patches/sources/net/minecraft/server/commands/CommandWorldBorder.patch

@@ -0,0 +1,65 @@
+--- a/net/minecraft/server/commands/CommandWorldBorder.java
++++ b/net/minecraft/server/commands/CommandWorldBorder.java
+@@ -57,7 +57,7 @@
+     }
+ 
+     private static int setDamageBuffer(CommandListenerWrapper commandlistenerwrapper, float f) throws CommandSyntaxException {
+-        WorldBorder worldborder = commandlistenerwrapper.getServer().overworld().getWorldBorder();
++        WorldBorder worldborder = commandlistenerwrapper.getLevel().getWorldBorder(); // CraftBukkit
+ 
+         if (worldborder.getDamageSafeZone() == (double) f) {
+             throw CommandWorldBorder.ERROR_SAME_DAMAGE_BUFFER.create();
+@@ -71,7 +71,7 @@
+     }
+ 
+     private static int setDamageAmount(CommandListenerWrapper commandlistenerwrapper, float f) throws CommandSyntaxException {
+-        WorldBorder worldborder = commandlistenerwrapper.getServer().overworld().getWorldBorder();
++        WorldBorder worldborder = commandlistenerwrapper.getLevel().getWorldBorder(); // CraftBukkit
+ 
+         if (worldborder.getDamagePerBlock() == (double) f) {
+             throw CommandWorldBorder.ERROR_SAME_DAMAGE_AMOUNT.create();
+@@ -85,7 +85,7 @@
+     }
+ 
+     private static int setWarningTime(CommandListenerWrapper commandlistenerwrapper, int i) throws CommandSyntaxException {
+-        WorldBorder worldborder = commandlistenerwrapper.getServer().overworld().getWorldBorder();
++        WorldBorder worldborder = commandlistenerwrapper.getLevel().getWorldBorder(); // CraftBukkit
+ 
+         if (worldborder.getWarningTime() == i) {
+             throw CommandWorldBorder.ERROR_SAME_WARNING_TIME.create();
+@@ -99,7 +99,7 @@
+     }
+ 
+     private static int setWarningDistance(CommandListenerWrapper commandlistenerwrapper, int i) throws CommandSyntaxException {
+-        WorldBorder worldborder = commandlistenerwrapper.getServer().overworld().getWorldBorder();
++        WorldBorder worldborder = commandlistenerwrapper.getLevel().getWorldBorder(); // CraftBukkit
+ 
+         if (worldborder.getWarningBlocks() == i) {
+             throw CommandWorldBorder.ERROR_SAME_WARNING_DISTANCE.create();
+@@ -113,7 +113,7 @@
+     }
+ 
+     private static int getSize(CommandListenerWrapper commandlistenerwrapper) {
+-        double d0 = commandlistenerwrapper.getServer().overworld().getWorldBorder().getSize();
++        double d0 = commandlistenerwrapper.getLevel().getWorldBorder().getSize(); // CraftBukkit
+ 
+         commandlistenerwrapper.sendSuccess(() -> {
+             return IChatBaseComponent.translatable("commands.worldborder.get", String.format(Locale.ROOT, "%.0f", d0));
+@@ -122,7 +122,7 @@
+     }
+ 
+     private static int setCenter(CommandListenerWrapper commandlistenerwrapper, Vec2F vec2f) throws CommandSyntaxException {
+-        WorldBorder worldborder = commandlistenerwrapper.getServer().overworld().getWorldBorder();
++        WorldBorder worldborder = commandlistenerwrapper.getLevel().getWorldBorder(); // CraftBukkit
+ 
+         if (worldborder.getCenterX() == (double) vec2f.x && worldborder.getCenterZ() == (double) vec2f.y) {
+             throw CommandWorldBorder.ERROR_SAME_CENTER.create();
+@@ -138,7 +138,7 @@
+     }
+ 
+     private static int setSize(CommandListenerWrapper commandlistenerwrapper, double d0, long i) throws CommandSyntaxException {
+-        WorldBorder worldborder = commandlistenerwrapper.getServer().overworld().getWorldBorder();
++        WorldBorder worldborder = commandlistenerwrapper.getLevel().getWorldBorder(); // CraftBukkit
+         double d1 = worldborder.getSize();
+ 
+         if (d1 == d0) {

paper-server/patches/sources/net/minecraft/server/commands/PlaceCommand.patch

@@ -0,0 +1,10 @@
+--- a/net/minecraft/server/commands/PlaceCommand.java
++++ b/net/minecraft/server/commands/PlaceCommand.java
+@@ -132,6 +132,7 @@
+         if (!structurestart.isValid()) {
+             throw PlaceCommand.ERROR_STRUCTURE_FAILED.create();
+         } else {
++            structurestart.generationEventCause = org.bukkit.event.world.AsyncStructureGenerateEvent.Cause.COMMAND; // CraftBukkit - set AsyncStructureGenerateEvent.Cause.COMMAND as generation cause
+             StructureBoundingBox structureboundingbox = structurestart.getBoundingBox();
+             ChunkCoordIntPair chunkcoordintpair = new ChunkCoordIntPair(SectionPosition.blockToSectionCoord(structureboundingbox.minX()), SectionPosition.blockToSectionCoord(structureboundingbox.minZ()));
+             ChunkCoordIntPair chunkcoordintpair1 = new ChunkCoordIntPair(SectionPosition.blockToSectionCoord(structureboundingbox.maxX()), SectionPosition.blockToSectionCoord(structureboundingbox.maxZ()));

paper-server/patches/sources/net/minecraft/server/dedicated/DedicatedServer.patch

@@ -0,0 +1,269 @@
+--- a/net/minecraft/server/dedicated/DedicatedServer.java
++++ b/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -59,6 +59,18 @@
+ import net.minecraft.world.level.storage.Convertable;
+ import org.slf4j.Logger;
+ 
++// CraftBukkit start
++import net.minecraft.server.WorldLoader;
++import org.apache.logging.log4j.Level;
++import org.apache.logging.log4j.LogManager;
++import org.apache.logging.log4j.io.IoBuilder;
++import org.bukkit.command.CommandSender;
++import org.bukkit.craftbukkit.util.TerminalCompletionHandler;
++import org.bukkit.craftbukkit.util.TerminalConsoleWriterThread;
++import org.bukkit.event.server.ServerCommandEvent;
++import org.bukkit.event.server.RemoteServerCommandEvent;
++// CraftBukkit end
++
+ public class DedicatedServer extends MinecraftServer implements IMinecraftServer {
+ 
+     static final Logger LOGGER = LogUtils.getLogger();
+@@ -67,7 +79,7 @@
+     private final List<ServerCommand> consoleInput = Collections.synchronizedList(Lists.newArrayList());
+     @Nullable
+     private RemoteStatusListener queryThreadGs4;
+-    private final RemoteControlCommandListener rconConsoleSource;
++    // private final RemoteControlCommandListener rconConsoleSource; // CraftBukkit - remove field
+     @Nullable
+     private RemoteControlListener rconThread;
+     public DedicatedServerSettings settings;
+@@ -81,10 +93,12 @@
+     private DebugSampleSubscriptionTracker debugSampleSubscriptionTracker;
+     public ServerLinks serverLinks;
+ 
+-    public DedicatedServer(Thread thread, Convertable.ConversionSession convertable_conversionsession, ResourcePackRepository resourcepackrepository, WorldStem worldstem, DedicatedServerSettings dedicatedserversettings, DataFixer datafixer, Services services, WorldLoadListenerFactory worldloadlistenerfactory) {
+-        super(thread, convertable_conversionsession, resourcepackrepository, worldstem, Proxy.NO_PROXY, datafixer, services, worldloadlistenerfactory);
++    // CraftBukkit start - Signature changed
++    public DedicatedServer(joptsimple.OptionSet options, WorldLoader.a worldLoader, Thread thread, Convertable.ConversionSession convertable_conversionsession, ResourcePackRepository resourcepackrepository, WorldStem worldstem, DedicatedServerSettings dedicatedserversettings, DataFixer datafixer, Services services, WorldLoadListenerFactory worldloadlistenerfactory) {
++        super(options, worldLoader, thread, convertable_conversionsession, resourcepackrepository, worldstem, Proxy.NO_PROXY, datafixer, services, worldloadlistenerfactory);
++        // CraftBukkit end
+         this.settings = dedicatedserversettings;
+-        this.rconConsoleSource = new RemoteControlCommandListener(this);
++        // this.rconConsoleSource = new RemoteControlCommandListener(this); // CraftBukkit - remove field
+         this.serverTextFilter = ServerTextFilter.createFromConfig(dedicatedserversettings.getProperties());
+         this.serverLinks = createServerLinks(dedicatedserversettings);
+     }
+@@ -93,13 +107,44 @@
+     public boolean initServer() throws IOException {
+         Thread thread = new Thread("Server console handler") {
+             public void run() {
+-                BufferedReader bufferedreader = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8));
++                // CraftBukkit start
++                if (!org.bukkit.craftbukkit.Main.useConsole) {
++                    return;
++                }
++                jline.console.ConsoleReader bufferedreader = reader;
++
++                // MC-33041, SPIGOT-5538: if System.in is not valid due to javaw, then return
++                try {
++                    System.in.available();
++                } catch (IOException ex) {
++                    return;
++                }
++                // CraftBukkit end
+ 
+                 String s;
+ 
+                 try {
+-                    while (!DedicatedServer.this.isStopped() && DedicatedServer.this.isRunning() && (s = bufferedreader.readLine()) != null) {
+-                        DedicatedServer.this.handleConsoleInput(s, DedicatedServer.this.createCommandSourceStack());
++                    // CraftBukkit start - JLine disabling compatibility
++                    while (!DedicatedServer.this.isStopped() && DedicatedServer.this.isRunning()) {
++                        if (org.bukkit.craftbukkit.Main.useJline) {
++                            s = bufferedreader.readLine(">", null);
++                        } else {
++                            s = bufferedreader.readLine();
++                        }
++
++                        // SPIGOT-5220: Throttle if EOF (ctrl^d) or stdin is /dev/null
++                        if (s == null) {
++                            try {
++                                Thread.sleep(50L);
++                            } catch (InterruptedException ex) {
++                                Thread.currentThread().interrupt();
++                            }
++                            continue;
++                        }
++                        if (s.trim().length() > 0) { // Trim to filter lines which are just spaces
++                            DedicatedServer.this.handleConsoleInput(s, DedicatedServer.this.createCommandSourceStack());
++                        }
++                        // CraftBukkit end
+                     }
+                 } catch (IOException ioexception) {
+                     DedicatedServer.LOGGER.error("Exception handling console input", ioexception);
+@@ -108,6 +153,29 @@
+             }
+         };
+ 
++        // CraftBukkit start - TODO: handle command-line logging arguments
++        java.util.logging.Logger global = java.util.logging.Logger.getLogger("");
++        global.setUseParentHandlers(false);
++        for (java.util.logging.Handler handler : global.getHandlers()) {
++            global.removeHandler(handler);
++        }
++        global.addHandler(new org.bukkit.craftbukkit.util.ForwardLogHandler());
++
++        final org.apache.logging.log4j.core.Logger logger = ((org.apache.logging.log4j.core.Logger) LogManager.getRootLogger());
++        for (org.apache.logging.log4j.core.Appender appender : logger.getAppenders().values()) {
++            if (appender instanceof org.apache.logging.log4j.core.appender.ConsoleAppender) {
++                logger.removeAppender(appender);
++            }
++        }
++
++        TerminalConsoleWriterThread writerThread = new TerminalConsoleWriterThread(System.out, this.reader);
++        this.reader.setCompletionHandler(new TerminalCompletionHandler(writerThread, this.reader.getCompletionHandler()));
++        writerThread.start();
++
++        System.setOut(IoBuilder.forLogger(logger).setLevel(Level.INFO).buildPrintStream());
++        System.setErr(IoBuilder.forLogger(logger).setLevel(Level.WARN).buildPrintStream());
++        // CraftBukkit end
++
+         thread.setDaemon(true);
+         thread.setUncaughtExceptionHandler(new DefaultUncaughtExceptionHandler(DedicatedServer.LOGGER));
+         thread.start();
+@@ -132,7 +200,7 @@
+         this.setMotd(dedicatedserverproperties.motd);
+         super.setPlayerIdleTimeout((Integer) dedicatedserverproperties.playerIdleTimeout.get());
+         this.setEnforceWhitelist(dedicatedserverproperties.enforceWhitelist);
+-        this.worldData.setGameType(dedicatedserverproperties.gamemode);
++        // this.worldData.setGameType(dedicatedserverproperties.gamemode); // CraftBukkit - moved to world loading
+         DedicatedServer.LOGGER.info("Default game type: {}", dedicatedserverproperties.gamemode);
+         InetAddress inetaddress = null;
+ 
+@@ -156,6 +224,12 @@
+             return false;
+         }
+ 
++        // CraftBukkit start
++        this.setPlayerList(new DedicatedPlayerList(this, this.registries(), this.playerDataStorage));
++        server.loadPlugins();
++        server.enablePlugins(org.bukkit.plugin.PluginLoadOrder.STARTUP);
++        // CraftBukkit end
++
+         if (!this.usesAuthentication()) {
+             DedicatedServer.LOGGER.warn("**** SERVER IS RUNNING IN OFFLINE/INSECURE MODE!");
+             DedicatedServer.LOGGER.warn("The server will make no attempt to authenticate usernames. Beware.");
+@@ -170,7 +244,7 @@
+         if (!NameReferencingFileConverter.serverReadyAfterUserconversion(this)) {
+             return false;
+         } else {
+-            this.setPlayerList(new DedicatedPlayerList(this, this.registries(), this.playerDataStorage));
++            // this.setPlayerList(new DedicatedPlayerList(this, this.registries(), this.playerDataStorage)); // CraftBukkit - moved up
+             this.debugSampleSubscriptionTracker = new DebugSampleSubscriptionTracker(this.getPlayerList());
+             this.tickTimeLogger = new RemoteSampleLogger(TpsDebugDimensions.values().length, this.debugSampleSubscriptionTracker, RemoteDebugSampleType.TICK_TIME);
+             long i = SystemUtils.getNanos();
+@@ -178,13 +252,13 @@
+             TileEntitySkull.setup(this.services, this);
+             UserCache.setUsesAuthentication(this.usesAuthentication());
+             DedicatedServer.LOGGER.info("Preparing level \"{}\"", this.getLevelIdName());
+-            this.loadLevel();
++            this.loadLevel(storageSource.getLevelId()); // CraftBukkit
+             long j = SystemUtils.getNanos() - i;
+             String s = String.format(Locale.ROOT, "%.3fs", (double) j / 1.0E9D);
+ 
+             DedicatedServer.LOGGER.info("Done ({})! For help, type \"help\"", s);
+             if (dedicatedserverproperties.announcePlayerAchievements != null) {
+-                ((GameRules.GameRuleBoolean) this.getGameRules().getRule(GameRules.RULE_ANNOUNCE_ADVANCEMENTS)).set(dedicatedserverproperties.announcePlayerAchievements, this);
++                ((GameRules.GameRuleBoolean) this.getGameRules().getRule(GameRules.RULE_ANNOUNCE_ADVANCEMENTS)).set(dedicatedserverproperties.announcePlayerAchievements, this.overworld()); // CraftBukkit - per-world
+             }
+ 
+             if (dedicatedserverproperties.enableQuery) {
+@@ -293,6 +367,7 @@
+             this.queryThreadGs4.stop();
+         }
+ 
++        System.exit(0); // CraftBukkit
+     }
+ 
+     @Override
+@@ -314,7 +389,15 @@
+         while (!this.consoleInput.isEmpty()) {
+             ServerCommand servercommand = (ServerCommand) this.consoleInput.remove(0);
+ 
+-            this.getCommands().performPrefixedCommand(servercommand.source, servercommand.msg);
++            // CraftBukkit start - ServerCommand for preprocessing
++            ServerCommandEvent event = new ServerCommandEvent(console, servercommand.msg);
++            server.getPluginManager().callEvent(event);
++            if (event.isCancelled()) continue;
++            servercommand = new ServerCommand(event.getCommand(), servercommand.source);
++
++            // this.getCommands().performPrefixedCommand(servercommand.source, servercommand.msg); // Called in dispatchServerCommand
++            server.dispatchServerCommand(console, servercommand);
++            // CraftBukkit end
+         }
+ 
+     }
+@@ -541,16 +624,52 @@
+ 
+     @Override
+     public String getPluginNames() {
+-        return "";
++        // CraftBukkit start - Whole method
++        StringBuilder result = new StringBuilder();
++        org.bukkit.plugin.Plugin[] plugins = server.getPluginManager().getPlugins();
++
++        result.append(server.getName());
++        result.append(" on Bukkit ");
++        result.append(server.getBukkitVersion());
++
++        if (plugins.length > 0 && server.getQueryPlugins()) {
++            result.append(": ");
++
++            for (int i = 0; i < plugins.length; i++) {
++                if (i > 0) {
++                    result.append("; ");
++                }
++
++                result.append(plugins[i].getDescription().getName());
++                result.append(" ");
++                result.append(plugins[i].getDescription().getVersion().replaceAll(";", ","));
++            }
++        }
++
++        return result.toString();
++        // CraftBukkit end
+     }
+ 
+     @Override
+     public String runCommand(String s) {
+-        this.rconConsoleSource.prepareForCommand();
++        // CraftBukkit start - fire RemoteServerCommandEvent
++        throw new UnsupportedOperationException("Not supported - remote source required.");
++    }
++
++    public String runCommand(RemoteControlCommandListener rconConsoleSource, String s) {
++        rconConsoleSource.prepareForCommand();
+         this.executeBlocking(() -> {
+-            this.getCommands().performPrefixedCommand(this.rconConsoleSource.createCommandSourceStack(), s);
++            CommandListenerWrapper wrapper = rconConsoleSource.createCommandSourceStack();
++            RemoteServerCommandEvent event = new RemoteServerCommandEvent(rconConsoleSource.getBukkitSender(wrapper), s);
++            server.getPluginManager().callEvent(event);
++            if (event.isCancelled()) {
++                return;
++            }
++            ServerCommand serverCommand = new ServerCommand(event.getCommand(), wrapper);
++            server.dispatchServerCommand(event.getSender(), serverCommand);
+         });
+-        return this.rconConsoleSource.getCommandResponse();
++        return rconConsoleSource.getCommandResponse();
++        // CraftBukkit end
+     }
+ 
+     public void storeUsingWhiteList(boolean flag) {
+@@ -660,4 +779,15 @@
+             }
+         }
+     }
++
++    // CraftBukkit start
++    public boolean isDebugging() {
++        return this.getProperties().debug;
++    }
++
++    @Override
++    public CommandSender getBukkitSender(CommandListenerWrapper wrapper) {
++        return console;
++    }
++    // CraftBukkit end
+ }

paper-server/patches/sources/net/minecraft/server/dedicated/DedicatedServerProperties.patch

@@ -0,0 +1,80 @@
+--- a/net/minecraft/server/dedicated/DedicatedServerProperties.java
++++ b/net/minecraft/server/dedicated/DedicatedServerProperties.java
+@@ -43,11 +43,16 @@
+ import net.minecraft.world.level.levelgen.presets.WorldPresets;
+ import org.slf4j.Logger;
+ 
++// CraftBukkit start
++import joptsimple.OptionSet;
++// CraftBukkit end
++
+ public class DedicatedServerProperties extends PropertyManager<DedicatedServerProperties> {
+ 
+     static final Logger LOGGER = LogUtils.getLogger();
+     private static final Pattern SHA1 = Pattern.compile("^[a-fA-F0-9]{40}$");
+     private static final Splitter COMMA_SPLITTER = Splitter.on(',').trimResults();
++    public final boolean debug = this.get("debug", false); // CraftBukkit
+     public final boolean onlineMode = this.get("online-mode", true);
+     public final boolean preventProxyConnections = this.get("prevent-proxy-connections", false);
+     public final String serverIp = this.get("server-ip", "");
+@@ -100,13 +105,15 @@
+     public final PropertyManager<DedicatedServerProperties>.EditableProperty<Boolean> whiteList;
+     public final boolean enforceSecureProfile;
+     public final boolean logIPs;
+-    public final int pauseWhenEmptySeconds;
++    public int pauseWhenEmptySeconds;
+     private final DedicatedServerProperties.WorldDimensionData worldDimensionData;
+     public final WorldOptions worldOptions;
+     public boolean acceptsTransfers;
+ 
+-    public DedicatedServerProperties(Properties properties) {
+-        super(properties);
++    // CraftBukkit start
++    public DedicatedServerProperties(Properties properties, OptionSet optionset) {
++        super(properties, optionset);
++        // CraftBukkit end
+         this.difficulty = (EnumDifficulty) this.get("difficulty", dispatchNumberOrString(EnumDifficulty::byId, EnumDifficulty::byName), EnumDifficulty::getKey, EnumDifficulty.EASY);
+         this.gamemode = (EnumGamemode) this.get("gamemode", dispatchNumberOrString(EnumGamemode::byId, EnumGamemode::byName), EnumGamemode::getName, EnumGamemode.SURVIVAL);
+         this.levelName = this.get("level-name", "world");
+@@ -167,13 +174,15 @@
+         this.initialDataPackConfiguration = getDatapackConfig(this.get("initial-enabled-packs", String.join(",", WorldDataConfiguration.DEFAULT.dataPacks().getEnabled())), this.get("initial-disabled-packs", String.join(",", WorldDataConfiguration.DEFAULT.dataPacks().getDisabled())));
+     }
+ 
+-    public static DedicatedServerProperties fromFile(Path path) {
+-        return new DedicatedServerProperties(loadFromFile(path));
++    // CraftBukkit start
++    public static DedicatedServerProperties fromFile(Path path, OptionSet optionset) {
++        return new DedicatedServerProperties(loadFromFile(path), optionset);
+     }
+ 
+     @Override
+-    protected DedicatedServerProperties reload(IRegistryCustom iregistrycustom, Properties properties) {
+-        return new DedicatedServerProperties(properties);
++    protected DedicatedServerProperties reload(IRegistryCustom iregistrycustom, Properties properties, OptionSet optionset) {
++        return new DedicatedServerProperties(properties, optionset);
++        // CraftBukkit end
+     }
+ 
+     @Nullable
+@@ -254,10 +263,10 @@
+             }).orElseThrow(() -> {
+                 return new IllegalStateException("Invalid datapack contents: can't find default preset");
+             });
+-            Optional optional = Optional.ofNullable(MinecraftKey.tryParse(this.levelType)).map((minecraftkey) -> {
++            Optional<ResourceKey<WorldPreset>> optional = Optional.ofNullable(MinecraftKey.tryParse(this.levelType)).map((minecraftkey) -> { // CraftBukkit - decompile error
+                 return ResourceKey.create(Registries.WORLD_PRESET, minecraftkey);
+             }).or(() -> {
+-                return Optional.ofNullable((ResourceKey) DedicatedServerProperties.WorldDimensionData.LEGACY_PRESET_NAMES.get(this.levelType));
++                return Optional.ofNullable(DedicatedServerProperties.WorldDimensionData.LEGACY_PRESET_NAMES.get(this.levelType)); // CraftBukkit - decompile error
+             });
+ 
+             Objects.requireNonNull(holderlookup);
+@@ -269,7 +278,7 @@
+ 
+             if (holder.is(WorldPresets.FLAT)) {
+                 RegistryOps<JsonElement> registryops = holderlookup_a.createSerializationContext(JsonOps.INSTANCE);
+-                DataResult dataresult = GeneratorSettingsFlat.CODEC.parse(new Dynamic(registryops, this.generatorSettings()));
++                DataResult<GeneratorSettingsFlat> dataresult = GeneratorSettingsFlat.CODEC.parse(new Dynamic(registryops, this.generatorSettings())); // CraftBukkit - decompile error
+                 Logger logger = DedicatedServerProperties.LOGGER;
+ 
+                 Objects.requireNonNull(logger);

paper-server/patches/sources/net/minecraft/server/dedicated/DedicatedServerSettings.patch

@@ -0,0 +1,27 @@
+--- a/net/minecraft/server/dedicated/DedicatedServerSettings.java
++++ b/net/minecraft/server/dedicated/DedicatedServerSettings.java
+@@ -3,14 +3,21 @@
+ import java.nio.file.Path;
+ import java.util.function.UnaryOperator;
+ 
++// CraftBukkit start
++import java.io.File;
++import joptsimple.OptionSet;
++// CraftBukkit end
++
+ public class DedicatedServerSettings {
+ 
+     private final Path source;
+     private DedicatedServerProperties properties;
+ 
+-    public DedicatedServerSettings(Path path) {
+-        this.source = path;
+-        this.properties = DedicatedServerProperties.fromFile(path);
++    // CraftBukkit start
++    public DedicatedServerSettings(OptionSet optionset) {
++        this.source = ((File) optionset.valueOf("config")).toPath();
++        this.properties = DedicatedServerProperties.fromFile(source, optionset);
++        // CraftBukkit end
+     }
+ 
+     public DedicatedServerProperties getProperties() {

paper-server/patches/sources/net/minecraft/server/dedicated/PropertyManager.patch

@@ -0,0 +1,124 @@
+--- a/net/minecraft/server/dedicated/PropertyManager.java
++++ b/net/minecraft/server/dedicated/PropertyManager.java
+@@ -23,17 +23,37 @@
+ import net.minecraft.core.IRegistryCustom;
+ import org.slf4j.Logger;
+ 
++import joptsimple.OptionSet; // CraftBukkit
++
+ public abstract class PropertyManager<T extends PropertyManager<T>> {
+ 
+     private static final Logger LOGGER = LogUtils.getLogger();
+     public final Properties properties;
++    // CraftBukkit start
++    private OptionSet options = null;
+ 
+-    public PropertyManager(Properties properties) {
++    public PropertyManager(Properties properties, final OptionSet options) {
+         this.properties = properties;
++
++        this.options = options;
++    }
++
++    private String getOverride(String name, String value) {
++        if ((this.options != null) && (this.options.has(name))) {
++            return String.valueOf(this.options.valueOf(name));
++        }
++
++        return value;
++        // CraftBukkit end
+     }
+ 
+     public static Properties loadFromFile(Path path) {
+         try {
++            // CraftBukkit start - SPIGOT-7465, MC-264979: Don't load if file doesn't exist
++            if (!path.toFile().exists()) {
++                return new Properties();
++            }
++            // CraftBukkit end
+             Properties properties;
+             Properties properties1;
+ 
+@@ -97,6 +117,11 @@
+ 
+     public void store(Path path) {
+         try {
++            // CraftBukkit start - Don't attempt writing to file if it's read only
++            if (path.toFile().exists() && !path.toFile().canWrite()) {
++                return;
++            }
++            // CraftBukkit end
+             BufferedWriter bufferedwriter = Files.newBufferedWriter(path, StandardCharsets.UTF_8);
+ 
+             try {
+@@ -125,7 +150,7 @@
+     private static <V extends Number> Function<String, V> wrapNumberDeserializer(Function<String, V> function) {
+         return (s) -> {
+             try {
+-                return (Number) function.apply(s);
++                return (V) function.apply(s); // CraftBukkit - decompile error
+             } catch (NumberFormatException numberformatexception) {
+                 return null;
+             }
+@@ -144,7 +169,7 @@
+ 
+     @Nullable
+     private String getStringRaw(String s) {
+-        return (String) this.properties.get(s);
++        return (String) getOverride(s, this.properties.getProperty(s)); // CraftBukkit
+     }
+ 
+     @Nullable
+@@ -160,6 +185,16 @@
+     }
+ 
+     protected <V> V get(String s, Function<String, V> function, Function<V, String> function1, V v0) {
++        // CraftBukkit start
++        try {
++            return get0(s, function, function1, v0);
++        } catch (Exception ex) {
++            throw new RuntimeException("Could not load invalidly configured property '" + s + "'", ex);
++        }
++    }
++
++    private <V> V get0(String s, Function<String, V> function, Function<V, String> function1, V v0) {
++        // CraftBukkit end
+         String s1 = this.getStringRaw(s);
+         V v1 = MoreObjects.firstNonNull(s1 != null ? function.apply(s1) : null, v0);
+ 
+@@ -172,7 +207,7 @@
+         V v1 = MoreObjects.firstNonNull(s1 != null ? function.apply(s1) : null, v0);
+ 
+         this.properties.put(s, function1.apply(v1));
+-        return new PropertyManager.EditableProperty<>(s, v1, function1);
++        return new PropertyManager.EditableProperty(s, v1, function1); // CraftBukkit - decompile error
+     }
+ 
+     protected <V> V get(String s, Function<String, V> function, UnaryOperator<V> unaryoperator, Function<V, String> function1, V v0) {
+@@ -236,7 +271,7 @@
+         return properties;
+     }
+ 
+-    protected abstract T reload(IRegistryCustom iregistrycustom, Properties properties);
++    protected abstract T reload(IRegistryCustom iregistrycustom, Properties properties, OptionSet optionset); // CraftBukkit
+ 
+     public class EditableProperty<V> implements Supplier<V> {
+ 
+@@ -244,7 +279,7 @@
+         private final V value;
+         private final Function<V, String> serializer;
+ 
+-        EditableProperty(final String s, final Object object, final Function function) {
++        EditableProperty(final String s, final V object, final Function function) { // CraftBukkit - decompile error
+             this.key = s;
+             this.value = object;
+             this.serializer = function;
+@@ -258,7 +293,7 @@
+             Properties properties = PropertyManager.this.cloneProperties();
+ 
+             properties.put(this.key, this.serializer.apply(v0));
+-            return PropertyManager.this.reload(iregistrycustom, properties);
++            return PropertyManager.this.reload(iregistrycustom, properties, PropertyManager.this.options); // CraftBukkit
+         }
+     }
+ }

paper-server/patches/sources/net/minecraft/server/gui/ServerGUI.patch

@@ -0,0 +1,37 @@
+--- a/net/minecraft/server/gui/ServerGUI.java
++++ b/net/minecraft/server/gui/ServerGUI.java
+@@ -96,7 +96,7 @@
+     private JComponent buildInfoPanel() {
+         JPanel jpanel = new JPanel(new BorderLayout());
+         GuiStatsComponent guistatscomponent = new GuiStatsComponent(this.server);
+-        Collection collection = this.finalizers;
++        Collection<Runnable> collection = this.finalizers; // CraftBukkit - decompile error
+ 
+         Objects.requireNonNull(guistatscomponent);
+         collection.add(guistatscomponent::close);
+@@ -132,7 +132,7 @@
+ 
+             jtextfield.setText("");
+         });
+-        jtextarea.addFocusListener(new FocusAdapter(this) {
++        jtextarea.addFocusListener(new FocusAdapter() { // CraftBukkit - decompile error
+             public void focusGained(FocusEvent focusevent) {}
+         });
+         jpanel.add(jscrollpane, "Center");
+@@ -166,6 +166,7 @@
+         this.finalizers.forEach(Runnable::run);
+     }
+ 
++    private static final java.util.regex.Pattern ANSI = java.util.regex.Pattern.compile("\\x1B\\[([0-9]{1,2}(;[0-9]{1,2})*)?[m|K]"); // CraftBukkit
+     public void print(JTextArea jtextarea, JScrollPane jscrollpane, String s) {
+         if (!SwingUtilities.isEventDispatchThread()) {
+             SwingUtilities.invokeLater(() -> {
+@@ -181,7 +182,7 @@
+             }
+ 
+             try {
+-                document.insertString(document.getLength(), s, (AttributeSet) null);
++                document.insertString(document.getLength(), ANSI.matcher(s).replaceAll(""), (AttributeSet) null); // CraftBukkit
+             } catch (BadLocationException badlocationexception) {
+                 ;
+             }

paper-server/patches/sources/net/minecraft/server/level/ChunkMapDistance.patch

@@ -0,0 +1,124 @@
+--- a/net/minecraft/server/level/ChunkMapDistance.java
++++ b/net/minecraft/server/level/ChunkMapDistance.java
+@@ -117,6 +117,15 @@
+ 
+             PlayerChunk playerchunk;
+ 
++            // CraftBukkit start - SPIGOT-7780: Call chunk unload events before updateHighestAllowedStatus
++            while (iterator.hasNext()) {
++                playerchunk = (PlayerChunk) iterator.next();
++                playerchunk.callEventIfUnloading(playerchunkmap);
++            }
++
++            iterator = this.chunksToUpdateFutures.iterator();
++            // CraftBukkit end
++
+             while (iterator.hasNext()) {
+                 playerchunk = (PlayerChunk) iterator.next();
+                 playerchunk.updateHighestAllowedStatus(playerchunkmap);
+@@ -165,7 +174,7 @@
+         }
+     }
+ 
+-    void addTicket(long i, Ticket<?> ticket) {
++    boolean addTicket(long i, Ticket<?> ticket) { // CraftBukkit - void -> boolean
+         ArraySetSorted<Ticket<?>> arraysetsorted = this.getTickets(i);
+         int j = getTicketLevelAt(arraysetsorted);
+         Ticket<?> ticket1 = (Ticket) arraysetsorted.addOrGet(ticket);
+@@ -175,13 +184,15 @@
+             this.ticketTracker.update(i, ticket.getTicketLevel(), true);
+         }
+ 
++        return ticket == ticket1; // CraftBukkit
+     }
+ 
+-    void removeTicket(long i, Ticket<?> ticket) {
++    boolean removeTicket(long i, Ticket<?> ticket) { // CraftBukkit - void -> boolean
+         ArraySetSorted<Ticket<?>> arraysetsorted = this.getTickets(i);
+ 
++        boolean removed = false; // CraftBukkit
+         if (arraysetsorted.remove(ticket)) {
+-            ;
++            removed = true; // CraftBukkit
+         }
+ 
+         if (arraysetsorted.isEmpty()) {
+@@ -189,6 +200,7 @@
+         }
+ 
+         this.ticketTracker.update(i, getTicketLevelAt(arraysetsorted), false);
++        return removed; // CraftBukkit
+     }
+ 
+     public <T> void addTicket(TicketType<T> tickettype, ChunkCoordIntPair chunkcoordintpair, int i, T t0) {
+@@ -202,19 +214,33 @@
+     }
+ 
+     public <T> void addRegionTicket(TicketType<T> tickettype, ChunkCoordIntPair chunkcoordintpair, int i, T t0) {
++        // CraftBukkit start
++        addRegionTicketAtDistance(tickettype, chunkcoordintpair, i, t0);
++    }
++
++    public <T> boolean addRegionTicketAtDistance(TicketType<T> tickettype, ChunkCoordIntPair chunkcoordintpair, int i, T t0) {
++        // CraftBukkit end
+         Ticket<T> ticket = new Ticket<>(tickettype, ChunkLevel.byStatus(FullChunkStatus.FULL) - i, t0);
+         long j = chunkcoordintpair.toLong();
+ 
+-        this.addTicket(j, ticket);
++        boolean added = this.addTicket(j, ticket); // CraftBukkit
+         this.tickingTicketsTracker.addTicket(j, ticket);
++        return added; // CraftBukkit
+     }
+ 
+     public <T> void removeRegionTicket(TicketType<T> tickettype, ChunkCoordIntPair chunkcoordintpair, int i, T t0) {
++        // CraftBukkit start
++        removeRegionTicketAtDistance(tickettype, chunkcoordintpair, i, t0);
++    }
++
++    public <T> boolean removeRegionTicketAtDistance(TicketType<T> tickettype, ChunkCoordIntPair chunkcoordintpair, int i, T t0) {
++        // CraftBukkit end
+         Ticket<T> ticket = new Ticket<>(tickettype, ChunkLevel.byStatus(FullChunkStatus.FULL) - i, t0);
+         long j = chunkcoordintpair.toLong();
+ 
+-        this.removeTicket(j, ticket);
++        boolean removed = this.removeTicket(j, ticket); // CraftBukkit
+         this.tickingTicketsTracker.removeTicket(j, ticket);
++        return removed; // CraftBukkit
+     }
+ 
+     private ArraySetSorted<Ticket<?>> getTickets(long i) {
+@@ -253,6 +279,7 @@
+         ChunkCoordIntPair chunkcoordintpair = sectionposition.chunk();
+         long i = chunkcoordintpair.toLong();
+         ObjectSet<EntityPlayer> objectset = (ObjectSet) this.playersPerChunk.get(i);
++        if (objectset == null) return; // CraftBukkit - SPIGOT-6208
+ 
+         objectset.remove(entityplayer);
+         if (objectset.isEmpty()) {
+@@ -391,6 +418,26 @@
+         return !this.tickets.isEmpty();
+     }
+ 
++    // CraftBukkit start
++    public <T> void removeAllTicketsFor(TicketType<T> ticketType, int ticketLevel, T ticketIdentifier) {
++        Ticket<T> target = new Ticket<>(ticketType, ticketLevel, ticketIdentifier);
++
++        for (java.util.Iterator<Entry<ArraySetSorted<Ticket<?>>>> iterator = this.tickets.long2ObjectEntrySet().fastIterator(); iterator.hasNext();) {
++            Entry<ArraySetSorted<Ticket<?>>> entry = iterator.next();
++            ArraySetSorted<Ticket<?>> tickets = entry.getValue();
++            if (tickets.remove(target)) {
++                // copied from removeTicket
++                this.ticketTracker.update(entry.getLongKey(), getTicketLevelAt(tickets), false);
++
++                // can't use entry after it's removed
++                if (tickets.isEmpty()) {
++                    iterator.remove();
++                }
++            }
++        }
++    }
++    // CraftBukkit end
++
+     private class a extends ChunkMap {
+ 
+         private static final int MAX_LEVEL = ChunkLevel.MAX_LEVEL + 1;

paper-server/patches/sources/net/minecraft/server/level/ChunkProviderServer.patch

@@ -0,0 +1,154 @@
+--- a/net/minecraft/server/level/ChunkProviderServer.java
++++ b/net/minecraft/server/level/ChunkProviderServer.java
+@@ -96,6 +96,16 @@
+         this.clearCache();
+     }
+ 
++    // CraftBukkit start - properly implement isChunkLoaded
++    public boolean isChunkLoaded(int chunkX, int chunkZ) {
++        PlayerChunk chunk = this.chunkMap.getUpdatingChunkIfPresent(ChunkCoordIntPair.asLong(chunkX, chunkZ));
++        if (chunk == null) {
++            return false;
++        }
++        return chunk.getFullChunkNow() != null;
++    }
++    // CraftBukkit end
++
+     @Override
+     public LightEngineThreaded getLightEngine() {
+         return this.lightEngine;
+@@ -139,7 +149,7 @@
+                 if (k == this.lastChunkPos[l] && chunkstatus == this.lastChunkStatus[l]) {
+                     IChunkAccess ichunkaccess = this.lastChunk[l];
+ 
+-                    if (ichunkaccess != null || !flag) {
++                    if (ichunkaccess != null) { // CraftBukkit - the chunk can become accessible in the meantime TODO for non-null chunks it might also make sense to check that the chunk's state hasn't changed in the meantime
+                         return ichunkaccess;
+                     }
+                 }
+@@ -152,7 +162,7 @@
+             Objects.requireNonNull(completablefuture);
+             chunkproviderserver_b.managedBlock(completablefuture::isDone);
+             ChunkResult<IChunkAccess> chunkresult = (ChunkResult) completablefuture.join();
+-            IChunkAccess ichunkaccess1 = (IChunkAccess) chunkresult.orElse((Object) null);
++            IChunkAccess ichunkaccess1 = (IChunkAccess) chunkresult.orElse(null); // CraftBukkit - decompile error
+ 
+             if (ichunkaccess1 == null && flag) {
+                 throw (IllegalStateException) SystemUtils.pauseInIde(new IllegalStateException("Chunk not there when requested: " + chunkresult.getError()));
+@@ -232,7 +242,15 @@
+         int l = ChunkLevel.byStatus(chunkstatus);
+         PlayerChunk playerchunk = this.getVisibleChunkIfPresent(k);
+ 
+-        if (flag) {
++        // CraftBukkit start - don't add new ticket for currently unloading chunk
++        boolean currentlyUnloading = false;
++        if (playerchunk != null) {
++            FullChunkStatus oldChunkState = ChunkLevel.fullStatus(playerchunk.oldTicketLevel);
++            FullChunkStatus currentChunkState = ChunkLevel.fullStatus(playerchunk.getTicketLevel());
++            currentlyUnloading = (oldChunkState.isOrAfter(FullChunkStatus.FULL) && !currentChunkState.isOrAfter(FullChunkStatus.FULL));
++        }
++        if (flag && !currentlyUnloading) {
++            // CraftBukkit end
+             this.distanceManager.addTicket(TicketType.UNKNOWN, chunkcoordintpair, l, chunkcoordintpair);
+             if (this.chunkAbsent(playerchunk, l)) {
+                 GameProfilerFiller gameprofilerfiller = Profiler.get();
+@@ -251,7 +269,7 @@
+     }
+ 
+     private boolean chunkAbsent(@Nullable PlayerChunk playerchunk, int i) {
+-        return playerchunk == null || playerchunk.getTicketLevel() > i;
++        return playerchunk == null || playerchunk.oldTicketLevel > i; // CraftBukkit using oldTicketLevel for isLoaded checks
+     }
+ 
+     @Override
+@@ -310,12 +328,34 @@
+ 
+     @Override
+     public void close() throws IOException {
+-        this.save(true);
++        // CraftBukkit start
++        close(true);
++    }
++
++    public void close(boolean save) throws IOException {
++        if (save) {
++            this.save(true);
++        }
++        // CraftBukkit end
+         this.dataStorage.close();
+         this.lightEngine.close();
+         this.chunkMap.close();
+     }
+ 
++    // CraftBukkit start - modelled on below
++    public void purgeUnload() {
++        GameProfilerFiller gameprofilerfiller = Profiler.get();
++
++        gameprofilerfiller.push("purge");
++        this.distanceManager.purgeStaleTickets();
++        this.runDistanceManagerUpdates();
++        gameprofilerfiller.popPush("unload");
++        this.chunkMap.tick(() -> true);
++        gameprofilerfiller.pop();
++        this.clearCache();
++    }
++    // CraftBukkit end
++
+     @Override
+     public void tick(BooleanSupplier booleansupplier, boolean flag) {
+         GameProfilerFiller gameprofilerfiller = Profiler.get();
+@@ -402,14 +442,14 @@
+ 
+         this.lastSpawnState = spawnercreature_d;
+         gameprofilerfiller.popPush("spawnAndTick");
+-        boolean flag = this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING);
++        boolean flag = this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && !this.level.players().isEmpty(); // CraftBukkit
+         int k = this.level.getGameRules().getInt(GameRules.RULE_RANDOMTICKING);
+         List list1;
+ 
+         if (flag && (this.spawnEnemies || this.spawnFriendlies)) {
+-            boolean flag1 = this.level.getLevelData().getGameTime() % 400L == 0L;
++            boolean flag1 = this.level.ticksPerSpawnCategory.getLong(org.bukkit.entity.SpawnCategory.ANIMAL) != 0L && this.level.getLevelData().getGameTime() % this.level.ticksPerSpawnCategory.getLong(org.bukkit.entity.SpawnCategory.ANIMAL) == 0L; // CraftBukkit
+ 
+-            list1 = SpawnerCreature.getFilteredSpawningCategories(spawnercreature_d, this.spawnFriendlies, this.spawnEnemies, flag1);
++            list1 = SpawnerCreature.getFilteredSpawningCategories(spawnercreature_d, this.spawnFriendlies, this.spawnEnemies, flag1, this.level); // CraftBukkit
+         } else {
+             list1 = List.of();
+         }
+@@ -542,8 +582,14 @@
+ 
+     @Override
+     public void setSpawnSettings(boolean flag) {
++        // CraftBukkit start
++        this.setSpawnSettings(flag, this.spawnFriendlies);
++    }
++
++    public void setSpawnSettings(boolean flag, boolean spawnFriendlies) {
+         this.spawnEnemies = flag;
+-        this.spawnFriendlies = this.spawnFriendlies;
++        this.spawnFriendlies = spawnFriendlies;
++        // CraftBukkit end
+     }
+ 
+     public String getChunkDebugData(ChunkCoordIntPair chunkcoordintpair) {
+@@ -619,13 +665,19 @@
+         }
+ 
+         @Override
+-        protected boolean pollTask() {
++        // CraftBukkit start - process pending Chunk loadCallback() and unloadCallback() after each run task
++        public boolean pollTask() {
++        try {
+             if (ChunkProviderServer.this.runDistanceManagerUpdates()) {
+                 return true;
+             } else {
+                 ChunkProviderServer.this.lightEngine.tryScheduleUpdate();
+                 return super.pollTask();
+             }
++        } finally {
++            chunkMap.callbackExecutor.run();
++        }
++        // CraftBukkit end
+         }
+     }
+ 

paper-server/patches/sources/net/minecraft/server/level/EntityTrackerEntry.patch

@@ -0,0 +1,134 @@
+--- a/net/minecraft/server/level/EntityTrackerEntry.java
++++ b/net/minecraft/server/level/EntityTrackerEntry.java
+@@ -50,6 +50,12 @@
+ import net.minecraft.world.phys.Vec3D;
+ import org.slf4j.Logger;
+ 
++// CraftBukkit start
++import net.minecraft.server.network.ServerPlayerConnection;
++import org.bukkit.entity.Player;
++import org.bukkit.event.player.PlayerVelocityEvent;
++// CraftBukkit end
++
+ public class EntityTrackerEntry {
+ 
+     private static final Logger LOGGER = LogUtils.getLogger();
+@@ -74,8 +80,12 @@
+     private boolean wasOnGround;
+     @Nullable
+     private List<DataWatcher.c<?>> trackedDataValues;
++    // CraftBukkit start
++    private final Set<ServerPlayerConnection> trackedPlayers;
+ 
+-    public EntityTrackerEntry(WorldServer worldserver, Entity entity, int i, boolean flag, Consumer<Packet<?>> consumer) {
++    public EntityTrackerEntry(WorldServer worldserver, Entity entity, int i, boolean flag, Consumer<Packet<?>> consumer, Set<ServerPlayerConnection> trackedPlayers) {
++        this.trackedPlayers = trackedPlayers;
++        // CraftBukkit end
+         this.level = worldserver;
+         this.broadcast = consumer;
+         this.entity = entity;
+@@ -94,7 +104,7 @@
+         List<Entity> list = this.entity.getPassengers();
+ 
+         if (!list.equals(this.lastPassengers)) {
+-            this.broadcast.accept(new PacketPlayOutMount(this.entity));
++            this.broadcastAndSend(new PacketPlayOutMount(this.entity)); // CraftBukkit
+             removedPassengers(list, this.lastPassengers).forEach((entity) -> {
+                 if (entity instanceof EntityPlayer entityplayer) {
+                     entityplayer.connection.teleport(entityplayer.getX(), entityplayer.getY(), entityplayer.getZ(), entityplayer.getYRot(), entityplayer.getXRot());
+@@ -107,18 +117,18 @@
+         Entity entity = this.entity;
+ 
+         if (entity instanceof EntityItemFrame entityitemframe) {
+-            if (this.tickCount % 10 == 0) {
++            if (true || this.tickCount % 10 == 0) { // CraftBukkit - Moved below, should always enter this block
+                 ItemStack itemstack = entityitemframe.getItem();
+ 
+-                if (itemstack.getItem() instanceof ItemWorldMap) {
++                if (this.tickCount % 10 == 0 && itemstack.getItem() instanceof ItemWorldMap) { // CraftBukkit - Moved this.tickCounter % 10 logic here so item frames do not enter the other blocks
+                     MapId mapid = (MapId) itemstack.get(DataComponents.MAP_ID);
+                     WorldMap worldmap = ItemWorldMap.getSavedData(mapid, this.level);
+ 
+                     if (worldmap != null) {
+-                        Iterator iterator = this.level.players().iterator();
++                        Iterator<ServerPlayerConnection> iterator = this.trackedPlayers.iterator(); // CraftBukkit
+ 
+                         while (iterator.hasNext()) {
+-                            EntityPlayer entityplayer = (EntityPlayer) iterator.next();
++                            EntityPlayer entityplayer = iterator.next().getPlayer(); // CraftBukkit
+ 
+                             worldmap.tickCarriedBy(entityplayer, itemstack);
+                             Packet<?> packet = worldmap.getUpdatePacket(mapid, entityplayer);
+@@ -248,6 +258,27 @@
+ 
+         ++this.tickCount;
+         if (this.entity.hurtMarked) {
++            // CraftBukkit start - Create PlayerVelocity event
++            boolean cancelled = false;
++
++            if (this.entity instanceof EntityPlayer) {
++                Player player = (Player) this.entity.getBukkitEntity();
++                org.bukkit.util.Vector velocity = player.getVelocity();
++
++                PlayerVelocityEvent event = new PlayerVelocityEvent(player, velocity.clone());
++                this.entity.level().getCraftServer().getPluginManager().callEvent(event);
++
++                if (event.isCancelled()) {
++                    cancelled = true;
++                } else if (!velocity.equals(event.getVelocity())) {
++                    player.setVelocity(event.getVelocity());
++                }
++            }
++
++            if (cancelled) {
++                return;
++            }
++            // CraftBukkit end
+             this.entity.hurtMarked = false;
+             this.broadcastAndSend(new PacketPlayOutEntityVelocity(this.entity));
+         }
+@@ -298,7 +329,10 @@
+ 
+     public void sendPairingData(EntityPlayer entityplayer, Consumer<Packet<PacketListenerPlayOut>> consumer) {
+         if (this.entity.isRemoved()) {
+-            EntityTrackerEntry.LOGGER.warn("Fetching packet for removed entity {}", this.entity);
++            // CraftBukkit start - Remove useless error spam, just return
++            // EntityTrackerEntry.LOGGER.warn("Fetching packet for removed entity {}", this.entity);
++            return;
++            // CraftBukkit end
+         }
+ 
+         Packet<PacketListenerPlayOut> packet = this.entity.getAddEntityPacket(this);
+@@ -313,6 +347,12 @@
+         if (this.entity instanceof EntityLiving) {
+             Collection<AttributeModifiable> collection = ((EntityLiving) this.entity).getAttributes().getSyncableAttributes();
+ 
++            // CraftBukkit start - If sending own attributes send scaled health instead of current maximum health
++            if (this.entity.getId() == entityplayer.getId()) {
++                ((EntityPlayer) this.entity).getBukkitEntity().injectScaledMaxHealth(collection, false);
++            }
++            // CraftBukkit end
++
+             if (!collection.isEmpty()) {
+                 consumer.accept(new PacketPlayOutUpdateAttributes(this.entity.getId(), collection));
+             }
+@@ -344,6 +384,7 @@
+             if (!list.isEmpty()) {
+                 consumer.accept(new PacketPlayOutEntityEquipment(this.entity.getId(), list));
+             }
++            ((EntityLiving) this.entity).detectEquipmentUpdatesPublic(); // CraftBukkit - SPIGOT-3789: sync again immediately after sending
+         }
+ 
+         if (!this.entity.getPassengers().isEmpty()) {
+@@ -396,6 +437,11 @@
+             Set<AttributeModifiable> set = ((EntityLiving) this.entity).getAttributes().getAttributesToSync();
+ 
+             if (!set.isEmpty()) {
++                // CraftBukkit start - Send scaled max health
++                if (this.entity instanceof EntityPlayer) {
++                    ((EntityPlayer) this.entity).getBukkitEntity().injectScaledMaxHealth(set, false);
++                }
++                // CraftBukkit end
+                 this.broadcastAndSend(new PacketPlayOutUpdateAttributes(this.entity.getId(), set));
+             }
+ 

paper-server/patches/sources/net/minecraft/server/level/PlayerChunk.patch

@@ -0,0 +1,150 @@
+--- a/net/minecraft/server/level/PlayerChunk.java
++++ b/net/minecraft/server/level/PlayerChunk.java
+@@ -28,6 +28,10 @@
+ import net.minecraft.world.level.chunk.status.ChunkStatus;
+ import net.minecraft.world.level.lighting.LevelLightEngine;
+ 
++// CraftBukkit start
++import net.minecraft.server.MinecraftServer;
++// CraftBukkit end
++
+ public class PlayerChunk extends GenerationChunkHolder {
+ 
+     public static final ChunkResult<Chunk> UNLOADED_LEVEL_CHUNK = ChunkResult.error("Unloaded level chunk");
+@@ -58,9 +62,9 @@
+         this.entityTickingChunkFuture = PlayerChunk.UNLOADED_LEVEL_CHUNK_FUTURE;
+         this.blockChangedLightSectionFilter = new BitSet();
+         this.skyChangedLightSectionFilter = new BitSet();
+-        this.pendingFullStateConfirmation = CompletableFuture.completedFuture((Object) null);
+-        this.sendSync = CompletableFuture.completedFuture((Object) null);
+-        this.saveSync = CompletableFuture.completedFuture((Object) null);
++        this.pendingFullStateConfirmation = CompletableFuture.completedFuture(null); // CraftBukkit - decompile error
++        this.sendSync = CompletableFuture.completedFuture(null); // CraftBukkit - decompile error
++        this.saveSync = CompletableFuture.completedFuture(null); // CraftBukkit - decompile error
+         this.levelHeightAccessor = levelheightaccessor;
+         this.lightEngine = levellightengine;
+         this.onLevelChange = playerchunk_a;
+@@ -72,6 +76,18 @@
+         this.changedBlocksPerSection = new ShortSet[levelheightaccessor.getSectionsCount()];
+     }
+ 
++    // CraftBukkit start
++    public Chunk getFullChunkNow() {
++        // Note: We use the oldTicketLevel for isLoaded checks.
++        if (!ChunkLevel.fullStatus(this.oldTicketLevel).isOrAfter(FullChunkStatus.FULL)) return null;
++        return this.getFullChunkNowUnchecked();
++    }
++
++    public Chunk getFullChunkNowUnchecked() {
++        return (Chunk) this.getChunkIfPresentUnchecked(ChunkStatus.FULL);
++    }
++    // CraftBukkit end
++
+     public CompletableFuture<ChunkResult<Chunk>> getTickingChunkFuture() {
+         return this.tickingChunkFuture;
+     }
+@@ -86,7 +102,7 @@
+ 
+     @Nullable
+     public Chunk getTickingChunk() {
+-        return (Chunk) ((ChunkResult) this.getTickingChunkFuture().getNow(PlayerChunk.UNLOADED_LEVEL_CHUNK)).orElse((Object) null);
++        return (Chunk) ((ChunkResult) this.getTickingChunkFuture().getNow(PlayerChunk.UNLOADED_LEVEL_CHUNK)).orElse(null); // CraftBukkit - decompile error
+     }
+ 
+     @Nullable
+@@ -138,6 +154,7 @@
+             boolean flag = this.hasChangedSections;
+             int i = this.levelHeightAccessor.getSectionIndex(blockposition.getY());
+ 
++            if (i < 0 || i >= this.changedBlocksPerSection.length) return false; // CraftBukkit - SPIGOT-6086, SPIGOT-6296
+             if (this.changedBlocksPerSection[i] == null) {
+                 this.hasChangedSections = true;
+                 this.changedBlocksPerSection[i] = new ShortOpenHashSet();
+@@ -224,8 +241,11 @@
+                                 PacketPlayOutMultiBlockChange packetplayoutmultiblockchange = new PacketPlayOutMultiBlockChange(sectionposition, shortset, chunksection);
+ 
+                                 this.broadcast(list, packetplayoutmultiblockchange);
++                                // CraftBukkit start
++                                List finalList = list;
+                                 packetplayoutmultiblockchange.runUpdates((blockposition1, iblockdata1) -> {
+-                                    this.broadcastBlockEntityIfNeeded(list, world, blockposition1, iblockdata1);
++                                    this.broadcastBlockEntityIfNeeded(finalList, world, blockposition1, iblockdata1);
++                                    // CraftBukkit end
+                                 });
+                             }
+                         }
+@@ -291,7 +311,7 @@
+         this.pendingFullStateConfirmation = completablefuture1;
+         completablefuture.thenAccept((chunkresult) -> {
+             chunkresult.ifSuccess((chunk) -> {
+-                completablefuture1.complete((Object) null);
++                completablefuture1.complete(null); // CraftBukkit - decompile error
+             });
+         });
+     }
+@@ -301,6 +321,38 @@
+         playerchunkmap.onFullChunkStatusChange(this.pos, fullchunkstatus);
+     }
+ 
++    // CraftBukkit start
++    // ChunkUnloadEvent: Called before the chunk is unloaded: isChunkLoaded is still true and chunk can still be modified by plugins.
++    // SPIGOT-7780: Moved out of updateFutures to call all chunk unload events before calling updateHighestAllowedStatus for all chunks
++    protected void callEventIfUnloading(PlayerChunkMap playerchunkmap) {
++        FullChunkStatus oldFullChunkStatus = ChunkLevel.fullStatus(this.oldTicketLevel);
++        FullChunkStatus newFullChunkStatus = ChunkLevel.fullStatus(this.ticketLevel);
++        boolean oldIsFull = oldFullChunkStatus.isOrAfter(FullChunkStatus.FULL);
++        boolean newIsFull = newFullChunkStatus.isOrAfter(FullChunkStatus.FULL);
++        if (oldIsFull && !newIsFull) {
++            this.getFullChunkFuture().thenAccept((either) -> {
++                Chunk chunk = (Chunk) either.orElse(null);
++                if (chunk != null) {
++                    playerchunkmap.callbackExecutor.execute(() -> {
++                        // Minecraft will apply the chunks tick lists to the world once the chunk got loaded, and then store the tick
++                        // lists again inside the chunk once the chunk becomes inaccessible and set the chunk's needsSaving flag.
++                        // These actions may however happen deferred, so we manually set the needsSaving flag already here.
++                        chunk.markUnsaved();
++                        chunk.unloadCallback();
++                    });
++                }
++            }).exceptionally((throwable) -> {
++                // ensure exceptions are printed, by default this is not the case
++                MinecraftServer.LOGGER.error("Failed to schedule unload callback for chunk " + PlayerChunk.this.pos, throwable);
++                return null;
++            });
++
++            // Run callback right away if the future was already done
++            playerchunkmap.callbackExecutor.run();
++        }
++    }
++    // CraftBukkit end
++
+     protected void updateFutures(PlayerChunkMap playerchunkmap, Executor executor) {
+         FullChunkStatus fullchunkstatus = ChunkLevel.fullStatus(this.oldTicketLevel);
+         FullChunkStatus fullchunkstatus1 = ChunkLevel.fullStatus(this.ticketLevel);
+@@ -357,6 +409,26 @@
+ 
+         this.onLevelChange.onLevelChange(this.pos, this::getQueueLevel, this.ticketLevel, this::setQueueLevel);
+         this.oldTicketLevel = this.ticketLevel;
++        // CraftBukkit start
++        // ChunkLoadEvent: Called after the chunk is loaded: isChunkLoaded returns true and chunk is ready to be modified by plugins.
++        if (!fullchunkstatus.isOrAfter(FullChunkStatus.FULL) && fullchunkstatus1.isOrAfter(FullChunkStatus.FULL)) {
++            this.getFullChunkFuture().thenAccept((either) -> {
++                Chunk chunk = (Chunk) either.orElse(null);
++                if (chunk != null) {
++                    playerchunkmap.callbackExecutor.execute(() -> {
++                        chunk.loadCallback();
++                    });
++                }
++            }).exceptionally((throwable) -> {
++                // ensure exceptions are printed, by default this is not the case
++                MinecraftServer.LOGGER.error("Failed to schedule load callback for chunk " + PlayerChunk.this.pos, throwable);
++                return null;
++            });
++
++            // Run callback right away if the future was already done
++            playerchunkmap.callbackExecutor.run();
++        }
++        // CraftBukkit end
+     }
+ 
+     public boolean wasAccessibleSinceLastSave() {

paper-server/patches/sources/net/minecraft/server/level/PlayerChunkMap.patch

@@ -0,0 +1,123 @@
+--- a/net/minecraft/server/level/PlayerChunkMap.java
++++ b/net/minecraft/server/level/PlayerChunkMap.java
+@@ -104,6 +104,10 @@
+ import org.apache.commons.lang3.mutable.MutableBoolean;
+ import org.slf4j.Logger;
+ 
++// CraftBukkit start
++import org.bukkit.craftbukkit.generator.CustomChunkGenerator;
++// CraftBukkit end
++
+ public class PlayerChunkMap extends IChunkLoader implements PlayerChunk.b, GeneratingChunkMap {
+ 
+     private static final ChunkResult<List<IChunkAccess>> UNLOADED_CHUNK_LIST_RESULT = ChunkResult.error("Unloaded chunks found in range");
+@@ -149,6 +153,27 @@
+     public int serverViewDistance;
+     private final WorldGenContext worldGenContext;
+ 
++    // CraftBukkit start - recursion-safe executor for Chunk loadCallback() and unloadCallback()
++    public final CallbackExecutor callbackExecutor = new CallbackExecutor();
++    public static final class CallbackExecutor implements java.util.concurrent.Executor, Runnable {
++
++        private final java.util.Queue<Runnable> queue = new java.util.ArrayDeque<>();
++
++        @Override
++        public void execute(Runnable runnable) {
++            queue.add(runnable);
++        }
++
++        @Override
++        public void run() {
++            Runnable task;
++            while ((task = queue.poll()) != null) {
++                task.run();
++            }
++        }
++    };
++    // CraftBukkit end
++
+     public PlayerChunkMap(WorldServer worldserver, Convertable.ConversionSession convertable_conversionsession, DataFixer datafixer, StructureTemplateManager structuretemplatemanager, Executor executor, IAsyncTaskHandler<Runnable> iasynctaskhandler, ILightAccess ilightaccess, ChunkGenerator chunkgenerator, WorldLoadListener worldloadlistener, ChunkStatusUpdateListener chunkstatusupdatelistener, Supplier<WorldPersistentData> supplier, int i, boolean flag) {
+         super(new RegionStorageInfo(convertable_conversionsession.getLevelId(), worldserver.dimension(), "chunk"), convertable_conversionsession.getDimensionPath(worldserver.dimension()).resolve("region"), datafixer, flag);
+         this.visibleChunkMap = this.updatingChunkMap.clone();
+@@ -170,7 +195,13 @@
+         IRegistryCustom iregistrycustom = worldserver.registryAccess();
+         long j = worldserver.getSeed();
+ 
+-        if (chunkgenerator instanceof ChunkGeneratorAbstract chunkgeneratorabstract) {
++        // CraftBukkit start - SPIGOT-7051: It's a rigged game! Use delegate for random state creation, otherwise it is not so random.
++        ChunkGenerator randomGenerator = chunkgenerator;
++        if (randomGenerator instanceof CustomChunkGenerator customChunkGenerator) {
++            randomGenerator = customChunkGenerator.getDelegate();
++        }
++        if (randomGenerator instanceof ChunkGeneratorAbstract chunkgeneratorabstract) {
++            // CraftBukkit end
+             this.randomState = RandomState.create((GeneratorSettingBase) chunkgeneratorabstract.generatorSettings().value(), (HolderGetter) iregistrycustom.lookupOrThrow(Registries.NOISE), j);
+         } else {
+             this.randomState = RandomState.create(GeneratorSettingBase.dummy(), (HolderGetter) iregistrycustom.lookupOrThrow(Registries.NOISE), j);
+@@ -325,7 +356,7 @@
+                         throw this.debugFuturesAndCreateReportedException(new IllegalStateException("At least one of the chunk futures were null"), "n/a");
+                     }
+ 
+-                    IChunkAccess ichunkaccess = (IChunkAccess) chunkresult.orElse((Object) null);
++                    IChunkAccess ichunkaccess = (IChunkAccess) chunkresult.orElse(null); // CraftBukkit - decompile error
+ 
+                     if (ichunkaccess == null) {
+                         return PlayerChunkMap.UNLOADED_CHUNK_LIST_RESULT;
+@@ -977,7 +1008,8 @@
+                 return ichunkaccess instanceof Chunk ? Optional.of((Chunk) ichunkaccess) : Optional.empty();
+             });
+ 
+-            csvwriter.writeRow(chunkcoordintpair.x, chunkcoordintpair.z, playerchunk.getTicketLevel(), optional.isPresent(), optional.map(IChunkAccess::getPersistedStatus).orElse((Object) null), optional1.map(Chunk::getFullStatus).orElse((Object) null), printFuture(playerchunk.getFullChunkFuture()), printFuture(playerchunk.getTickingChunkFuture()), printFuture(playerchunk.getEntityTickingChunkFuture()), this.distanceManager.getTicketDebugString(i), this.anyPlayerCloseEnoughForSpawning(chunkcoordintpair), optional1.map((chunk) -> {
++            // CraftBukkit - decompile error
++            csvwriter.writeRow(chunkcoordintpair.x, chunkcoordintpair.z, playerchunk.getTicketLevel(), optional.isPresent(), optional.map(IChunkAccess::getPersistedStatus).orElse(null), optional1.map(Chunk::getFullStatus).orElse(null), printFuture(playerchunk.getFullChunkFuture()), printFuture(playerchunk.getTickingChunkFuture()), printFuture(playerchunk.getEntityTickingChunkFuture()), this.distanceManager.getTicketDebugString(i), this.anyPlayerCloseEnoughForSpawning(chunkcoordintpair), optional1.map((chunk) -> {
+                 return chunk.getBlockEntities().size();
+             }).orElse(0), tickingtracker.getTicketDebugString(i), tickingtracker.getLevel(i), optional1.map((chunk) -> {
+                 return chunk.getBlockTicks().count();
+@@ -990,7 +1022,7 @@
+ 
+     private static String printFuture(CompletableFuture<ChunkResult<Chunk>> completablefuture) {
+         try {
+-            ChunkResult<Chunk> chunkresult = (ChunkResult) completablefuture.getNow((Object) null);
++            ChunkResult<Chunk> chunkresult = (ChunkResult) completablefuture.getNow(null); // CraftBukkit - decompile error
+ 
+             return chunkresult != null ? (chunkresult.isSuccess() ? "done" : "unloaded") : "not completed";
+         } catch (CompletionException completionexception) {
+@@ -1002,12 +1034,14 @@
+ 
+     private CompletableFuture<Optional<NBTTagCompound>> readChunk(ChunkCoordIntPair chunkcoordintpair) {
+         return this.read(chunkcoordintpair).thenApplyAsync((optional) -> {
+-            return optional.map(this::upgradeChunkTag);
++            return optional.map((nbttagcompound) -> upgradeChunkTag(nbttagcompound, chunkcoordintpair)); // CraftBukkit
+         }, SystemUtils.backgroundExecutor().forName("upgradeChunk"));
+     }
+ 
+-    private NBTTagCompound upgradeChunkTag(NBTTagCompound nbttagcompound) {
+-        return this.upgradeChunkTag(this.level.dimension(), this.overworldDataStorage, nbttagcompound, this.generator().getTypeNameForDataFixer());
++    // CraftBukkit start
++    private NBTTagCompound upgradeChunkTag(NBTTagCompound nbttagcompound, ChunkCoordIntPair chunkcoordintpair) {
++        return this.upgradeChunkTag(this.level.getTypeKey(), this.overworldDataStorage, nbttagcompound, this.generator().getTypeNameForDataFixer(), chunkcoordintpair, level);
++        // CraftBukkit end
+     }
+ 
+     void forEachSpawnCandidateChunk(Consumer<PlayerChunk> consumer) {
+@@ -1424,7 +1458,7 @@
+         public final Set<ServerPlayerConnection> seenBy = Sets.newIdentityHashSet();
+ 
+         public EntityTracker(final Entity entity, final int i, final int j, final boolean flag) {
+-            this.serverEntity = new EntityTrackerEntry(PlayerChunkMap.this.level, entity, j, flag, this::broadcast);
++            this.serverEntity = new EntityTrackerEntry(PlayerChunkMap.this.level, entity, j, flag, this::broadcast, seenBy); // CraftBukkit
+             this.entity = entity;
+             this.range = i;
+             this.lastSectionPos = SectionPosition.of((EntityAccess) entity);
+@@ -1484,6 +1518,11 @@
+                 double d2 = d0 * d0;
+                 boolean flag = d1 <= d2 && this.entity.broadcastToPlayer(entityplayer) && PlayerChunkMap.this.isChunkTracked(entityplayer, this.entity.chunkPosition().x, this.entity.chunkPosition().z);
+ 
++                // CraftBukkit start - respect vanish API
++                if (!entityplayer.getBukkitEntity().canSee(this.entity.getBukkitEntity())) {
++                    flag = false;
++                }
++                // CraftBukkit end
+                 if (flag) {
+                     if (this.seenBy.add(entityplayer.connection)) {
+                         this.serverEntity.addPairing(entityplayer);

paper-server/patches/sources/net/minecraft/server/level/PlayerInteractManager.patch

@@ -0,0 +1,333 @@
+--- a/net/minecraft/server/level/PlayerInteractManager.java
++++ b/net/minecraft/server/level/PlayerInteractManager.java
+@@ -26,6 +26,27 @@
+ import net.minecraft.world.phys.Vec3D;
+ import org.slf4j.Logger;
+ 
++// CraftBukkit start
++import java.util.ArrayList;
++import net.minecraft.network.protocol.game.PacketPlayOutBlockChange;
++import net.minecraft.server.MinecraftServer;
++import net.minecraft.world.entity.EnumItemSlot;
++import net.minecraft.world.item.ItemBisected;
++import net.minecraft.world.level.block.BlockCake;
++import net.minecraft.world.level.block.BlockDoor;
++import net.minecraft.world.level.block.BlockTrapdoor;
++import net.minecraft.world.level.block.Blocks;
++import net.minecraft.world.level.block.state.properties.BlockPropertyDoubleBlockHalf;
++import org.bukkit.GameMode;
++import org.bukkit.craftbukkit.block.CraftBlock;
++import org.bukkit.event.block.BlockBreakEvent;
++import org.bukkit.craftbukkit.event.CraftEventFactory;
++import org.bukkit.event.Event;
++import org.bukkit.event.block.Action;
++import org.bukkit.event.player.PlayerGameModeChangeEvent;
++import org.bukkit.event.player.PlayerInteractEvent;
++// CraftBukkit end
++
+ public class PlayerInteractManager {
+ 
+     private static final Logger LOGGER = LogUtils.getLogger();
+@@ -56,9 +77,16 @@
+         if (enumgamemode == this.gameModeForPlayer) {
+             return false;
+         } else {
++            // CraftBukkit start
++            PlayerGameModeChangeEvent event = new PlayerGameModeChangeEvent(player.getBukkitEntity(), GameMode.getByValue(enumgamemode.getId()));
++            level.getCraftServer().getPluginManager().callEvent(event);
++            if (event.isCancelled()) {
++                return false;
++            }
++            // CraftBukkit end
+             this.setGameModeForPlayer(enumgamemode, this.previousGameModeForPlayer);
+             this.player.onUpdateAbilities();
+-            this.player.server.getPlayerList().broadcastAll(new ClientboundPlayerInfoUpdatePacket(ClientboundPlayerInfoUpdatePacket.a.UPDATE_GAME_MODE, this.player));
++            this.player.server.getPlayerList().broadcastAll(new ClientboundPlayerInfoUpdatePacket(ClientboundPlayerInfoUpdatePacket.a.UPDATE_GAME_MODE, this.player), this.player); // CraftBukkit
+             this.level.updateSleepingPlayerList();
+             if (enumgamemode == EnumGamemode.CREATIVE) {
+                 this.player.resetCurrentImpulseContext();
+@@ -92,7 +120,7 @@
+     }
+ 
+     public void tick() {
+-        ++this.gameTicks;
++        this.gameTicks = MinecraftServer.currentTick; // CraftBukkit;
+         IBlockData iblockdata;
+ 
+         if (this.hasDelayedDestroy) {
+@@ -146,11 +174,33 @@
+ 
+             if (packetplayinblockdig_enumplayerdigtype == PacketPlayInBlockDig.EnumPlayerDigType.START_DESTROY_BLOCK) {
+                 if (!this.level.mayInteract(this.player, blockposition)) {
++                    // CraftBukkit start - fire PlayerInteractEvent
++                    CraftEventFactory.callPlayerInteractEvent(this.player, Action.LEFT_CLICK_BLOCK, blockposition, enumdirection, this.player.getInventory().getSelected(), EnumHand.MAIN_HAND);
+                     this.player.connection.send(new PacketPlayOutBlockChange(blockposition, this.level.getBlockState(blockposition)));
+                     this.debugLogging(blockposition, false, j, "may not interact");
++                    // Update any tile entity data for this block
++                    TileEntity tileentity = level.getBlockEntity(blockposition);
++                    if (tileentity != null) {
++                        this.player.connection.send(tileentity.getUpdatePacket());
++                    }
++                    // CraftBukkit end
+                     return;
+                 }
+ 
++                // CraftBukkit start
++                PlayerInteractEvent event = CraftEventFactory.callPlayerInteractEvent(this.player, Action.LEFT_CLICK_BLOCK, blockposition, enumdirection, this.player.getInventory().getSelected(), EnumHand.MAIN_HAND);
++                if (event.isCancelled()) {
++                    // Let the client know the block still exists
++                    this.player.connection.send(new PacketPlayOutBlockChange(this.level, blockposition));
++                    // Update any tile entity data for this block
++                    TileEntity tileentity = this.level.getBlockEntity(blockposition);
++                    if (tileentity != null) {
++                        this.player.connection.send(tileentity.getUpdatePacket());
++                    }
++                    return;
++                }
++                // CraftBukkit end
++
+                 if (this.isCreative()) {
+                     this.destroyAndAck(blockposition, j, "creative destroy");
+                     return;
+@@ -166,7 +216,19 @@
+                 float f = 1.0F;
+ 
+                 iblockdata = this.level.getBlockState(blockposition);
+-                if (!iblockdata.isAir()) {
++                // CraftBukkit start - Swings at air do *NOT* exist.
++                if (event.useInteractedBlock() == Event.Result.DENY) {
++                    // If we denied a door from opening, we need to send a correcting update to the client, as it already opened the door.
++                    IBlockData data = this.level.getBlockState(blockposition);
++                    if (data.getBlock() instanceof BlockDoor) {
++                        // For some reason *BOTH* the bottom/top part have to be marked updated.
++                        boolean bottom = data.getValue(BlockDoor.HALF) == BlockPropertyDoubleBlockHalf.LOWER;
++                        this.player.connection.send(new PacketPlayOutBlockChange(this.level, blockposition));
++                        this.player.connection.send(new PacketPlayOutBlockChange(this.level, bottom ? blockposition.above() : blockposition.below()));
++                    } else if (data.getBlock() instanceof BlockTrapdoor) {
++                        this.player.connection.send(new PacketPlayOutBlockChange(this.level, blockposition));
++                    }
++                } else if (!iblockdata.isAir()) {
+                     EnchantmentManager.onHitBlock(this.level, this.player.getMainHandItem(), this.player, this.player, EnumItemSlot.MAINHAND, Vec3D.atCenterOf(blockposition), iblockdata, (item) -> {
+                         this.player.onEquippedItemBroken(item, EnumItemSlot.MAINHAND);
+                     });
+@@ -174,6 +236,26 @@
+                     f = iblockdata.getDestroyProgress(this.player, this.player.level(), blockposition);
+                 }
+ 
++                if (event.useItemInHand() == Event.Result.DENY) {
++                    // If we 'insta destroyed' then the client needs to be informed.
++                    if (f > 1.0f) {
++                        this.player.connection.send(new PacketPlayOutBlockChange(this.level, blockposition));
++                    }
++                    return;
++                }
++                org.bukkit.event.block.BlockDamageEvent blockEvent = CraftEventFactory.callBlockDamageEvent(this.player, blockposition, this.player.getInventory().getSelected(), f >= 1.0f);
++
++                if (blockEvent.isCancelled()) {
++                    // Let the client know the block still exists
++                    this.player.connection.send(new PacketPlayOutBlockChange(this.level, blockposition));
++                    return;
++                }
++
++                if (blockEvent.getInstaBreak()) {
++                    f = 2.0f;
++                }
++                // CraftBukkit end
++
+                 if (!iblockdata.isAir() && f >= 1.0F) {
+                     this.destroyAndAck(blockposition, j, "insta mine");
+                 } else {
+@@ -218,13 +300,15 @@
+             } else if (packetplayinblockdig_enumplayerdigtype == PacketPlayInBlockDig.EnumPlayerDigType.ABORT_DESTROY_BLOCK) {
+                 this.isDestroyingBlock = false;
+                 if (!Objects.equals(this.destroyPos, blockposition)) {
+-                    PlayerInteractManager.LOGGER.warn("Mismatch in destroy block pos: {} {}", this.destroyPos, blockposition);
++                    PlayerInteractManager.LOGGER.debug("Mismatch in destroy block pos: {} {}", this.destroyPos, blockposition); // CraftBukkit - SPIGOT-5457 sent by client when interact event cancelled
+                     this.level.destroyBlockProgress(this.player.getId(), this.destroyPos, -1);
+                     this.debugLogging(blockposition, true, j, "aborted mismatched destroying");
+                 }
+ 
+                 this.level.destroyBlockProgress(this.player.getId(), blockposition, -1);
+                 this.debugLogging(blockposition, true, j, "aborted destroying");
++
++                CraftEventFactory.callBlockDamageAbortEvent(this.player, blockposition, this.player.getInventory().getSelected()); // CraftBukkit
+             }
+ 
+         }
+@@ -242,10 +326,65 @@
+ 
+     public boolean destroyBlock(BlockPosition blockposition) {
+         IBlockData iblockdata = this.level.getBlockState(blockposition);
++        // CraftBukkit start - fire BlockBreakEvent
++        org.bukkit.block.Block bblock = CraftBlock.at(level, blockposition);
++        BlockBreakEvent event = null;
+ 
+-        if (!this.player.getMainHandItem().getItem().canAttackBlock(iblockdata, this.level, blockposition, this.player)) {
++        if (this.player instanceof EntityPlayer) {
++            // Sword + Creative mode pre-cancel
++            boolean isSwordNoBreak = !this.player.getMainHandItem().getItem().canAttackBlock(iblockdata, this.level, blockposition, this.player);
++
++            // Tell client the block is gone immediately then process events
++            // Don't tell the client if its a creative sword break because its not broken!
++            if (level.getBlockEntity(blockposition) == null && !isSwordNoBreak) {
++                PacketPlayOutBlockChange packet = new PacketPlayOutBlockChange(blockposition, Blocks.AIR.defaultBlockState());
++                this.player.connection.send(packet);
++            }
++
++            event = new BlockBreakEvent(bblock, this.player.getBukkitEntity());
++
++            // Sword + Creative mode pre-cancel
++            event.setCancelled(isSwordNoBreak);
++
++            // Calculate default block experience
++            IBlockData nmsData = this.level.getBlockState(blockposition);
++            Block nmsBlock = nmsData.getBlock();
++
++            ItemStack itemstack = this.player.getItemBySlot(EnumItemSlot.MAINHAND);
++
++            if (nmsBlock != null && !event.isCancelled() && !this.isCreative() && this.player.hasCorrectToolForDrops(nmsBlock.defaultBlockState())) {
++                event.setExpToDrop(nmsBlock.getExpDrop(nmsData, this.level, blockposition, itemstack, true));
++            }
++
++            this.level.getCraftServer().getPluginManager().callEvent(event);
++
++            if (event.isCancelled()) {
++                if (isSwordNoBreak) {
++                    return false;
++                }
++                // Let the client know the block still exists
++                this.player.connection.send(new PacketPlayOutBlockChange(this.level, blockposition));
++
++                // Brute force all possible updates
++                for (EnumDirection dir : EnumDirection.values()) {
++                    this.player.connection.send(new PacketPlayOutBlockChange(level, blockposition.relative(dir)));
++                }
++
++                // Update any tile entity data for this block
++                TileEntity tileentity = this.level.getBlockEntity(blockposition);
++                if (tileentity != null) {
++                    this.player.connection.send(tileentity.getUpdatePacket());
++                }
++                return false;
++            }
++        }
++        // CraftBukkit end
++
++        if (false && !this.player.getMainHandItem().getItem().canAttackBlock(iblockdata, this.level, blockposition, this.player)) { // CraftBukkit - false
+             return false;
+         } else {
++            iblockdata = this.level.getBlockState(blockposition); // CraftBukkit - update state from plugins
++            if (iblockdata.isAir()) return false; // CraftBukkit - A plugin set block to air without cancelling
+             TileEntity tileentity = this.level.getBlockEntity(blockposition);
+             Block block = iblockdata.getBlock();
+ 
+@@ -255,6 +394,10 @@
+             } else if (this.player.blockActionRestricted(this.level, blockposition, this.gameModeForPlayer)) {
+                 return false;
+             } else {
++                // CraftBukkit start
++                org.bukkit.block.BlockState state = bblock.getState();
++                level.captureDrops = new ArrayList<>();
++                // CraftBukkit end
+                 IBlockData iblockdata1 = block.playerWillDestroy(this.level, blockposition, iblockdata, this.player);
+                 boolean flag = this.level.removeBlock(blockposition, false);
+ 
+@@ -263,19 +406,32 @@
+                 }
+ 
+                 if (this.isCreative()) {
+-                    return true;
++                    // return true; // CraftBukkit
+                 } else {
+                     ItemStack itemstack = this.player.getMainHandItem();
+                     ItemStack itemstack1 = itemstack.copy();
+                     boolean flag1 = this.player.hasCorrectToolForDrops(iblockdata1);
+ 
+                     itemstack.mineBlock(this.level, iblockdata1, blockposition, this.player);
+-                    if (flag && flag1) {
++                    if (flag && flag1 && event.isDropItems()) { // CraftBukkit - Check if block should drop items
+                         block.playerDestroy(this.level, this.player, blockposition, iblockdata1, tileentity, itemstack1);
+                     }
+ 
+-                    return true;
++                    // return true; // CraftBukkit
++                }
++                // CraftBukkit start
++                if (event.isDropItems()) {
++                    org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockDropItemEvent(bblock, state, this.player, level.captureDrops);
++                }
++                level.captureDrops = null;
++
++                // Drop event experience
++                if (flag && event != null) {
++                    iblockdata.getBlock().popExperience(this.level, blockposition, event.getExpToDrop());
+                 }
++
++                return true;
++                // CraftBukkit end
+             }
+         }
+     }
+@@ -321,14 +477,53 @@
+         }
+     }
+ 
++    // CraftBukkit start - whole method
++    public boolean interactResult = false;
++    public boolean firedInteract = false;
++    public BlockPosition interactPosition;
++    public EnumHand interactHand;
++    public ItemStack interactItemStack;
+     public EnumInteractionResult useItemOn(EntityPlayer entityplayer, World world, ItemStack itemstack, EnumHand enumhand, MovingObjectPositionBlock movingobjectpositionblock) {
+         BlockPosition blockposition = movingobjectpositionblock.getBlockPos();
+         IBlockData iblockdata = world.getBlockState(blockposition);
++        boolean cancelledBlock = false;
+ 
+         if (!iblockdata.getBlock().isEnabled(world.enabledFeatures())) {
+             return EnumInteractionResult.FAIL;
+         } else if (this.gameModeForPlayer == EnumGamemode.SPECTATOR) {
+             ITileInventory itileinventory = iblockdata.getMenuProvider(world, blockposition);
++            cancelledBlock = !(itileinventory instanceof ITileInventory);
++        }
++
++        if (entityplayer.getCooldowns().isOnCooldown(itemstack)) {
++            cancelledBlock = true;
++        }
++
++        PlayerInteractEvent event = CraftEventFactory.callPlayerInteractEvent(entityplayer, Action.RIGHT_CLICK_BLOCK, blockposition, movingobjectpositionblock.getDirection(), itemstack, cancelledBlock, enumhand, movingobjectpositionblock.getLocation());
++        firedInteract = true;
++        interactResult = event.useItemInHand() == Event.Result.DENY;
++        interactPosition = blockposition.immutable();
++        interactHand = enumhand;
++        interactItemStack = itemstack.copy();
++
++        if (event.useInteractedBlock() == Event.Result.DENY) {
++            // If we denied a door from opening, we need to send a correcting update to the client, as it already opened the door.
++            if (iblockdata.getBlock() instanceof BlockDoor) {
++                boolean bottom = iblockdata.getValue(BlockDoor.HALF) == BlockPropertyDoubleBlockHalf.LOWER;
++                entityplayer.connection.send(new PacketPlayOutBlockChange(world, bottom ? blockposition.above() : blockposition.below()));
++            } else if (iblockdata.getBlock() instanceof BlockCake) {
++                entityplayer.getBukkitEntity().sendHealthUpdate(); // SPIGOT-1341 - reset health for cake
++            } else if (interactItemStack.getItem() instanceof ItemBisected) {
++                // send a correcting update to the client, as it already placed the upper half of the bisected item
++                entityplayer.connection.send(new PacketPlayOutBlockChange(world, blockposition.relative(movingobjectpositionblock.getDirection()).above()));
++
++                // send a correcting update to the client for the block above as well, this because of replaceable blocks (such as grass, sea grass etc)
++                entityplayer.connection.send(new PacketPlayOutBlockChange(world, blockposition.above()));
++            }
++            entityplayer.getBukkitEntity().updateInventory(); // SPIGOT-2867
++            return (event.useItemInHand() != Event.Result.ALLOW) ? EnumInteractionResult.SUCCESS : EnumInteractionResult.PASS;
++        } else if (this.gameModeForPlayer == EnumGamemode.SPECTATOR) {
++            ITileInventory itileinventory = iblockdata.getMenuProvider(world, blockposition);
+ 
+             if (itileinventory != null) {
+                 entityplayer.openMenu(itileinventory);
+@@ -359,7 +554,7 @@
+                 }
+             }
+ 
+-            if (!itemstack.isEmpty() && !entityplayer.getCooldowns().isOnCooldown(itemstack)) {
++            if (!itemstack.isEmpty() && !interactResult) { // add !interactResult SPIGOT-764
+                 ItemActionContext itemactioncontext = new ItemActionContext(entityplayer, enumhand, movingobjectpositionblock);
+ 
+                 if (this.isCreative()) {

paper-server/patches/sources/net/minecraft/server/level/RegionLimitedWorldAccess.patch

@@ -0,0 +1,25 @@
+--- a/net/minecraft/server/level/RegionLimitedWorldAccess.java
++++ b/net/minecraft/server/level/RegionLimitedWorldAccess.java
+@@ -217,7 +217,7 @@
+         if (iblockdata.isAir()) {
+             return false;
+         } else {
+-            if (flag) {
++            if (false) { // CraftBukkit - SPIGOT-6833: Do not drop during world generation
+                 TileEntity tileentity = iblockdata.hasBlockEntity() ? this.getBlockEntity(blockposition) : null;
+ 
+                 Block.dropResources(iblockdata, this.level, blockposition, tileentity, entity, ItemStack.EMPTY);
+@@ -336,6 +336,13 @@
+ 
+     @Override
+     public boolean addFreshEntity(Entity entity) {
++        // CraftBukkit start
++        return addFreshEntity(entity, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.DEFAULT);
++    }
++
++    @Override
++    public boolean addFreshEntity(Entity entity, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason reason) {
++        // CraftBukkit end
+         int i = SectionPosition.blockToSectionCoord(entity.getBlockX());
+         int j = SectionPosition.blockToSectionCoord(entity.getBlockZ());
+ 

paper-server/patches/sources/net/minecraft/server/level/TicketType.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/server/level/TicketType.java
++++ b/net/minecraft/server/level/TicketType.java
+@@ -22,6 +22,8 @@
+     public static final TicketType<BlockPosition> PORTAL = create("portal", BaseBlockPosition::compareTo, 300);
+     public static final TicketType<ChunkCoordIntPair> ENDER_PEARL = create("ender_pearl", Comparator.comparingLong(ChunkCoordIntPair::toLong), 40);
+     public static final TicketType<ChunkCoordIntPair> UNKNOWN = create("unknown", Comparator.comparingLong(ChunkCoordIntPair::toLong), 1);
++    public static final TicketType<Unit> PLUGIN = create("plugin", (a, b) -> 0); // CraftBukkit
++    public static final TicketType<org.bukkit.plugin.Plugin> PLUGIN_TICKET = create("plugin_ticket", (plugin1, plugin2) -> plugin1.getClass().getName().compareTo(plugin2.getClass().getName())); // CraftBukkit
+ 
+     public static <T> TicketType<T> create(String s, Comparator<T> comparator) {
+         return new TicketType<>(s, comparator, 0L);

paper-server/patches/sources/net/minecraft/server/level/WorldServer.patch

@@ -0,0 +1,619 @@
+--- a/net/minecraft/server/level/WorldServer.java
++++ b/net/minecraft/server/level/WorldServer.java
+@@ -174,6 +174,23 @@
+ import net.minecraft.world.ticks.TickListServer;
+ import org.slf4j.Logger;
+ 
++// CraftBukkit start
++import net.minecraft.world.level.biome.WorldChunkManager;
++import net.minecraft.world.level.dimension.WorldDimension;
++import net.minecraft.world.level.levelgen.ChunkGeneratorAbstract;
++import net.minecraft.world.level.levelgen.ChunkProviderFlat;
++import net.minecraft.world.level.storage.WorldDataServer;
++import org.bukkit.Bukkit;
++import org.bukkit.WeatherType;
++import org.bukkit.craftbukkit.event.CraftEventFactory;
++import org.bukkit.craftbukkit.generator.CustomWorldChunkManager;
++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.TimeSkipEvent;
++// CraftBukkit end
++
+ public class WorldServer extends World implements ServerEntityGetter, GeneratorAccessSeed {
+ 
+     public static final BlockPosition END_SPAWN_POINT = new BlockPosition(100, 50, 0);
+@@ -187,7 +204,7 @@
+     final List<EntityPlayer> players = Lists.newArrayList();
+     private final ChunkProviderServer chunkSource;
+     private final MinecraftServer server;
+-    public final IWorldDataServer serverLevelData;
++    public final WorldDataServer serverLevelData; // CraftBukkit - type
+     private int lastSpawnChunkRadius;
+     final EntityTickList entityTickList = new EntityTickList();
+     public final PersistentEntitySectionManager<Entity> entityManager;
+@@ -214,13 +231,47 @@
+     private final boolean tickTime;
+     private final RandomSequences randomSequences;
+ 
+-    public WorldServer(MinecraftServer minecraftserver, Executor executor, Convertable.ConversionSession convertable_conversionsession, IWorldDataServer iworlddataserver, ResourceKey<World> resourcekey, WorldDimension worlddimension, WorldLoadListener worldloadlistener, boolean flag, long i, List<MobSpawner> list, boolean flag1, @Nullable RandomSequences randomsequences) {
+-        super(iworlddataserver, resourcekey, minecraftserver.registryAccess(), worlddimension.type(), false, flag, i, minecraftserver.getMaxChainedNeighborUpdates());
++    // CraftBukkit start
++    public final Convertable.ConversionSession convertable;
++    public final UUID uuid;
++
++    public Chunk getChunkIfLoaded(int x, int z) {
++        return this.chunkSource.getChunk(x, z, false);
++    }
++
++    @Override
++    public ResourceKey<WorldDimension> getTypeKey() {
++        return convertable.dimensionType;
++    }
++
++    // Add env and gen to constructor, IWorldDataServer -> WorldDataServer
++    public WorldServer(MinecraftServer minecraftserver, Executor executor, Convertable.ConversionSession convertable_conversionsession, WorldDataServer iworlddataserver, ResourceKey<World> resourcekey, WorldDimension worlddimension, WorldLoadListener worldloadlistener, boolean flag, long i, List<MobSpawner> list, boolean flag1, @Nullable RandomSequences randomsequences, org.bukkit.World.Environment env, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider) {
++        super(iworlddataserver, resourcekey, minecraftserver.registryAccess(), worlddimension.type(), 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.tickTime = flag1;
+         this.server = minecraftserver;
+         this.customSpawners = list;
+         this.serverLevelData = iworlddataserver;
+         ChunkGenerator chunkgenerator = worlddimension.generator();
++        // CraftBukkit start
++        serverLevelData.setWorld(this);
++
++        if (biomeProvider != null) {
++            WorldChunkManager worldChunkManager = new CustomWorldChunkManager(getWorld(), biomeProvider, server.registryAccess().lookupOrThrow(Registries.BIOME));
++            if (chunkgenerator instanceof ChunkGeneratorAbstract cga) {
++                chunkgenerator = new ChunkGeneratorAbstract(worldChunkManager, cga.settings);
++            } else if (chunkgenerator instanceof ChunkProviderFlat cpf) {
++                chunkgenerator = new ChunkProviderFlat(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(new SimpleRegionStorage(new RegionStorageInfo(convertable_conversionsession.getLevelId(), resourcekey, "entities"), convertable_conversionsession.getDimensionPath(resourcekey).resolve("entities"), datafixer, flag2, DataFixTypes.ENTITY_CHUNK), this, minecraftserver);
+@@ -248,9 +299,9 @@
+         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() == World.END && this.dimensionTypeRegistration().is(BuiltinDimensionTypes.END)) {
+-            this.dragonFight = new EnderDragonBattle(this, l, minecraftserver.getWorldData().endDragonFightData());
++        this.structureManager = new StructureManager(this, this.serverLevelData.worldGenOptions(), structureCheck); // CraftBukkit
++        if ((this.dimension() == World.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 EnderDragonBattle(this, this.serverLevelData.worldGenOptions().seed(), this.serverLevelData.endDragonFightData()); // CraftBukkit
+         } else {
+             this.dragonFight = null;
+         }
+@@ -260,6 +311,7 @@
+         this.randomSequences = (RandomSequences) Objects.requireNonNullElseGet(randomsequences, () -> {
+             return (RandomSequences) this.getDataStorage().computeIfAbsent(RandomSequences.factory(l), "random_sequences");
+         });
++        this.getCraftServer().addWorld(this.getWorld()); // CraftBukkit
+     }
+ 
+     /** @deprecated */
+@@ -305,12 +357,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();
+             }
+@@ -345,7 +405,7 @@
+ 
+         this.handlingTick = false;
+         gameprofilerfiller.pop();
+-        boolean flag1 = !this.players.isEmpty() || !this.getForcedChunks().isEmpty();
++        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();
+@@ -429,7 +489,7 @@
+ 
+     private void wakeUpAllPlayers() {
+         this.sleepStatus.removeAllSleepers();
+-        ((List) this.players.stream().filter(EntityLiving::isSleeping).collect(Collectors.toList())).forEach((entityplayer) -> {
++        (this.players.stream().filter(EntityLiving::isSleeping).collect(Collectors.toList())).forEach((entityplayer) -> { // CraftBukkit - decompile error
+             entityplayer.stopSleepInBed(false, false);
+         });
+     }
+@@ -456,7 +516,7 @@
+                         entityhorseskeleton.setTrap(true);
+                         entityhorseskeleton.setAge(0);
+                         entityhorseskeleton.setPos((double) blockposition.getX(), (double) blockposition.getY(), (double) blockposition.getZ());
+-                        this.addFreshEntity(entityhorseskeleton);
++                        this.addFreshEntity(entityhorseskeleton, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.LIGHTNING); // CraftBukkit
+                     }
+                 }
+ 
+@@ -465,7 +525,7 @@
+                 if (entitylightning != null) {
+                     entitylightning.moveTo(Vec3D.atBottomCenterOf(blockposition));
+                     entitylightning.setVisualOnly(flag1);
+-                    this.addFreshEntity(entitylightning);
++                    this.strikeLightning(entitylightning, org.bukkit.event.weather.LightningStrikeEvent.Cause.WEATHER); // CraftBukkit
+                 }
+             }
+         }
+@@ -521,7 +581,7 @@
+         BiomeBase biomebase = (BiomeBase) this.getBiome(blockposition1).value();
+ 
+         if (biomebase.shouldFreeze(this, blockposition2)) {
+-            this.setBlockAndUpdate(blockposition2, Blocks.ICE.defaultBlockState());
++            org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(this, blockposition2, Blocks.ICE.defaultBlockState(), null); // CraftBukkit
+         }
+ 
+         if (this.isRaining()) {
+@@ -537,10 +597,10 @@
+                         IBlockData iblockdata1 = (IBlockData) iblockdata.setValue(BlockSnow.LAYERS, j + 1);
+ 
+                         Block.pushEntitiesUp(iblockdata, iblockdata1, this, blockposition1);
+-                        this.setBlockAndUpdate(blockposition1, iblockdata1);
++                        org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(this, blockposition1, iblockdata1, null); // CraftBukkit
+                     }
+                 } else {
+-                    this.setBlockAndUpdate(blockposition1, Blocks.SNOW.defaultBlockState());
++                    org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(this, blockposition1, Blocks.SNOW.defaultBlockState(), null); // CraftBukkit
+                 }
+             }
+ 
+@@ -701,6 +761,7 @@
+             this.rainLevel = MathHelper.clamp(this.rainLevel, 0.0F, 1.0F);
+         }
+ 
++        /* CraftBukkit start
+         if (this.oRainLevel != this.rainLevel) {
+             this.server.getPlayerList().broadcastAll(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.RAIN_LEVEL_CHANGE, this.rainLevel), this.dimension());
+         }
+@@ -719,15 +780,48 @@
+             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 (((EntityPlayer) this.players.get(idx)).level() == this) {
++                ((EntityPlayer) 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 (((EntityPlayer) this.players.get(idx)).level() == this) {
++                    ((EntityPlayer) this.players.get(idx)).setPlayerWeather((!flag ? WeatherType.DOWNFALL : WeatherType.CLEAR), false);
++                }
++            }
++        }
++        for (int idx = 0; idx < this.players.size(); ++idx) {
++            if (((EntityPlayer) this.players.get(idx)).level() == this) {
++                ((EntityPlayer) 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() {
+@@ -763,6 +857,7 @@
+         });
+         gameprofilerfiller.incrementCounter("tickNonPassenger");
+         entity.tick();
++        entity.postTick(); // CraftBukkit
+         gameprofilerfiller.pop();
+         Iterator iterator = entity.getPassengers().iterator();
+ 
+@@ -786,6 +881,7 @@
+                 });
+                 gameprofilerfiller.incrementCounter("tickPassenger");
+                 entity1.rideTick();
++                entity1.postTick(); // CraftBukkit
+                 gameprofilerfiller.pop();
+                 Iterator iterator = entity1.getPassengers().iterator();
+ 
+@@ -810,6 +906,7 @@
+         ChunkProviderServer chunkproviderserver = this.getChunkSource();
+ 
+         if (!flag1) {
++            org.bukkit.Bukkit.getPluginManager().callEvent(new org.bukkit.event.world.WorldSaveEvent(getWorld())); // CraftBukkit
+             if (iprogressupdate != null) {
+                 iprogressupdate.progressStartNoAbort(IChatBaseComponent.translatable("menu.savingLevel"));
+             }
+@@ -827,11 +924,19 @@
+             }
+ 
+         }
++
++        // CraftBukkit start - moved from MinecraftServer.saveChunks
++        WorldServer worldserver1 = this;
++
++        serverLevelData.setWorldBorder(worldserver1.getWorldBorder().createSettings());
++        serverLevelData.setCustomBossEvents(this.server.getCustomBossEvents().save(this.registryAccess()));
++        convertable.saveDataTag(this.server.registryAccess(), this.serverLevelData, this.server.getPlayerList().getSingleplayerData());
++        // CraftBukkit end
+     }
+ 
+     private void saveLevelData(boolean flag) {
+         if (this.dragonFight != null) {
+-            this.server.getWorldData().setEndDragonFightData(this.dragonFight.saveData());
++            this.serverLevelData.setEndDragonFightData(this.dragonFight.saveData()); // CraftBukkit
+         }
+ 
+         WorldPersistentData worldpersistentdata = this.getChunkSource().getDataStorage();
+@@ -903,18 +1008,40 @@
+ 
+     @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) {
++        // 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 addDuringTeleport(Entity entity, CreatureSpawnEvent.SpawnReason reason) {
++        // CraftBukkit end
+         if (entity instanceof EntityPlayer entityplayer) {
+             this.addPlayer(entityplayer);
+         } else {
+-            this.addEntity(entity);
++            this.addEntity(entity, reason); // CraftBukkit
+         }
+ 
+     }
+@@ -939,24 +1066,37 @@
+         this.entityManager.addNewEntity(entityplayer);
+     }
+ 
+-    private boolean addEntity(Entity entity) {
++    // CraftBukkit start
++    private boolean addEntity(Entity entity, CreatureSpawnEvent.SpawnReason spawnReason) {
+         if (entity.isRemoved()) {
+-            WorldServer.LOGGER.warn("Tried to add entity {} but it was marked as removed already", EntityTypes.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;
+         }
+     }
+@@ -967,13 +1107,35 @@
+     }
+ 
+     public void removePlayerImmediately(EntityPlayer entityplayer, Entity.RemovalReason entity_removalreason) {
+-        entityplayer.remove(entity_removalreason);
++        entityplayer.remove(entity_removalreason, null); // CraftBukkit - add Bukkit remove cause
+     }
+ 
++    // 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
+     public void destroyBlockProgress(int i, BlockPosition blockposition, int j) {
+         Iterator iterator = this.server.getPlayerList().getPlayers().iterator();
+ 
++        // CraftBukkit start
++        EntityHuman entityhuman = null;
++        Entity entity = this.getEntity(i);
++        if (entity instanceof EntityHuman) entityhuman = (EntityHuman) entity;
++        // CraftBukkit end
++
+         while (iterator.hasNext()) {
+             EntityPlayer entityplayer = (EntityPlayer) iterator.next();
+ 
+@@ -982,6 +1144,12 @@
+                 double d1 = (double) blockposition.getY() - entityplayer.getY();
+                 double d2 = (double) blockposition.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) {
+                     entityplayer.connection.send(new PacketPlayOutBlockBreakAnimation(i, blockposition, j));
+                 }
+@@ -1060,7 +1228,18 @@
+             Iterator iterator = this.navigatingMobs.iterator();
+ 
+             while (iterator.hasNext()) {
+-                EntityInsentient entityinsentient = (EntityInsentient) iterator.next();
++                // CraftBukkit start - fix SPIGOT-6362
++                EntityInsentient entityinsentient;
++                try {
++                    entityinsentient = (EntityInsentient) 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(blockposition, iblockdata, iblockdata1, i);
++                    return;
++                }
++                // CraftBukkit end
+                 NavigationAbstract navigationabstract = entityinsentient.getNavigation();
+ 
+                 if (navigationabstract.shouldRecomputePath(blockposition)) {
+@@ -1126,6 +1305,12 @@
+ 
+     @Override
+     public void explode(@Nullable Entity entity, @Nullable DamageSource damagesource, @Nullable ExplosionDamageCalculator explosiondamagecalculator, double d0, double d1, double d2, float f, boolean flag, World.a world_a, ParticleParam particleparam, ParticleParam particleparam1, Holder<SoundEffect> holder) {
++        // CraftBukkit start
++        this.explode0(entity, damagesource, explosiondamagecalculator, d0, d1, d2, f, flag, world_a, particleparam, particleparam1, holder);
++    }
++
++    public ServerExplosion explode0(@Nullable Entity entity, @Nullable DamageSource damagesource, @Nullable ExplosionDamageCalculator explosiondamagecalculator, double d0, double d1, double d2, float f, boolean flag, World.a world_a, ParticleParam particleparam, ParticleParam particleparam1, Holder<SoundEffect> holder) {
++        // CraftBukkit end
+         Explosion.Effect explosion_effect;
+ 
+         switch (world_a) {
+@@ -1144,6 +1329,11 @@
+             case TRIGGER:
+                 explosion_effect = Explosion.Effect.TRIGGER_BLOCK;
+                 break;
++            // CraftBukkit start - handle custom explosion type
++            case STANDARD:
++                explosion_effect = Explosion.Effect.DESTROY;
++                break;
++            // CraftBukkit end
+             default:
+                 throw new MatchException((String) null, (Throwable) null);
+         }
+@@ -1153,6 +1343,11 @@
+         ServerExplosion serverexplosion = new ServerExplosion(this, entity, damagesource, explosiondamagecalculator, vec3d, f, flag, explosion_effect1);
+ 
+         serverexplosion.explode();
++        // CraftBukkit start
++        if (serverexplosion.wasCanceled) {
++            return serverexplosion;
++        }
++        // CraftBukkit end
+         ParticleParam particleparam2 = serverexplosion.isSmall() ? particleparam : particleparam1;
+         Iterator iterator = this.players.iterator();
+ 
+@@ -1166,6 +1361,7 @@
+             }
+         }
+ 
++        return serverexplosion; // CraftBukkit
+     }
+ 
+     private Explosion.Effect getDestroyType(GameRules.GameRuleKey<GameRules.GameRuleBoolean> gamerules_gamerulekey) {
+@@ -1226,15 +1422,22 @@
+     }
+ 
+     public <T extends ParticleParam> int sendParticles(T t0, double d0, double d1, double d2, int i, double d3, double d4, double d5, double d6) {
+-        return this.sendParticles(t0, false, false, d0, d1, d2, i, d3, d4, d5, d6);
++        return this.sendParticlesSource(null, t0, false, false, d0, d1, d2, i, d3, d4, d5, d6); // CraftBukkit - visibility api support
+     }
+ 
+     public <T extends ParticleParam> int sendParticles(T t0, boolean flag, boolean flag1, double d0, double d1, double d2, int i, double d3, double d4, double d5, double d6) {
++        return this.sendParticlesSource(null, t0, flag, flag1, d0, d1, d2, i, d3, d4, d5, d6); // CraftBukkit - visibility api support
++    }
++
++    // CraftBukkit start - visibility api support
++    public <T extends ParticleParam> int sendParticlesSource(EntityPlayer sender, T t0, boolean flag, boolean flag1, double d0, double d1, double d2, int i, double d3, double d4, double d5, double d6) {
++        // CraftBukkit end
+         PacketPlayOutWorldParticles packetplayoutworldparticles = new PacketPlayOutWorldParticles(t0, flag, flag1, d0, d1, d2, (float) d3, (float) d4, (float) d5, (float) d6, i);
+         int j = 0;
+ 
+         for (int k = 0; k < this.players.size(); ++k) {
+             EntityPlayer entityplayer = (EntityPlayer) this.players.get(k);
++            if (sender != null && !entityplayer.getBukkitEntity().canSee(sender.getBukkitEntity())) continue; // CraftBukkit
+ 
+             if (this.sendParticles(entityplayer, flag, d0, d1, d2, packetplayoutworldparticles)) {
+                 ++j;
+@@ -1292,7 +1495,7 @@
+ 
+     @Nullable
+     public BlockPosition findNearestMapStructure(TagKey<Structure> tagkey, BlockPosition blockposition, int i, boolean flag) {
+-        if (!this.server.getWorldData().worldGenOptions().generateStructures()) {
++        if (!this.serverLevelData.worldGenOptions().generateStructures()) { // CraftBukkit
+             return null;
+         } else {
+             Optional<HolderSet.Named<Structure>> optional = this.registryAccess().lookupOrThrow(Registries.STRUCTURE).get(tagkey);
+@@ -1334,11 +1537,22 @@
+     @Nullable
+     @Override
+     public WorldMap getMapData(MapId mapid) {
+-        return (WorldMap) this.getServer().overworld().getDataStorage().get(WorldMap.factory(), mapid.key());
++        // CraftBukkit start
++        WorldMap worldmap = (WorldMap) this.getServer().overworld().getDataStorage().get(WorldMap.factory(), mapid.key());
++        if (worldmap != null) {
++            worldmap.id = mapid;
++        }
++        return worldmap;
++        // CraftBukkit end
+     }
+ 
+     @Override
+     public void setMapData(MapId mapid, WorldMap worldmap) {
++        // CraftBukkit start
++        worldmap.id = mapid;
++        MapInitializeEvent event = new MapInitializeEvent(worldmap.mapView);
++        Bukkit.getServer().getPluginManager().callEvent(event);
++        // CraftBukkit end
+         this.getServer().overworld().getDataStorage().set(mapid.key(), worldmap);
+     }
+ 
+@@ -1649,6 +1863,11 @@
+     @Override
+     public void blockUpdated(BlockPosition blockposition, Block block) {
+         if (!this.isDebug()) {
++            // CraftBukkit start
++            if (populating) {
++                return;
++            }
++            // CraftBukkit end
+             this.updateNeighborsAt(blockposition, block);
+         }
+ 
+@@ -1668,12 +1887,12 @@
+     }
+ 
+     public boolean isFlat() {
+-        return this.server.getWorldData().isFlatWorld();
++        return this.serverLevelData.isFlatWorld(); // CraftBukkit
+     }
+ 
+     @Override
+     public long getSeed() {
+-        return this.server.getWorldData().worldGenOptions().seed();
++        return this.serverLevelData.worldGenOptions().seed(); // CraftBukkit
+     }
+ 
+     @Nullable
+@@ -1696,7 +1915,7 @@
+     private static <T> String getTypeCount(Iterable<T> iterable, Function<T, String> function) {
+         try {
+             Object2IntOpenHashMap<String> object2intopenhashmap = new Object2IntOpenHashMap();
+-            Iterator iterator = iterable.iterator();
++            Iterator<T> iterator = iterable.iterator(); // CraftBukkit - decompile error
+ 
+             while (iterator.hasNext()) {
+                 T t0 = iterator.next();
+@@ -1705,7 +1924,7 @@
+                 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();
+@@ -1864,6 +2083,8 @@
+             }
+ 
+             entity.updateDynamicGameEventListener(DynamicGameEventListener::add);
++            entity.inWorld = true; // CraftBukkit - Mark entity as in world
++            entity.valid = true; // CraftBukkit
+         }
+ 
+         public void onTrackingEnd(Entity entity) {
+@@ -1895,6 +2116,14 @@
+             }
+ 
+             entity.updateDynamicGameEventListener(DynamicGameEventListener::remove);
++            // CraftBukkit start
++            entity.valid = false;
++            if (!(entity instanceof EntityPlayer)) {
++                for (EntityPlayer player : players) {
++                    player.getBukkitEntity().onEntityRemove(entity);
++                }
++            }
++            // CraftBukkit end
+         }
+ 
+         public void onSectionChange(Entity entity) {

paper-server/patches/sources/net/minecraft/server/network/HandshakeListener.patch

@@ -0,0 +1,69 @@
+--- a/net/minecraft/server/network/HandshakeListener.java
++++ b/net/minecraft/server/network/HandshakeListener.java
+@@ -13,8 +13,17 @@
+ import net.minecraft.network.protocol.status.StatusProtocols;
+ import net.minecraft.server.MinecraftServer;
+ 
++// CraftBukkit start
++import java.net.InetAddress;
++import java.util.HashMap;
++// CraftBukkit end
++
+ public class HandshakeListener implements PacketHandshakingInListener {
+ 
++    // CraftBukkit start - add fields
++    private static final HashMap<InetAddress, Long> throttleTracker = new HashMap<InetAddress, Long>();
++    private static int throttleCounter = 0;
++    // CraftBukkit end
+     private static final IChatBaseComponent IGNORE_STATUS_REASON = IChatBaseComponent.translatable("disconnect.ignoring_status_request");
+     private final MinecraftServer server;
+     private final NetworkManager connection;
+@@ -26,6 +35,7 @@
+ 
+     @Override
+     public void handleIntention(PacketHandshakingInSetProtocol packethandshakinginsetprotocol) {
++        this.connection.hostname = packethandshakinginsetprotocol.hostName() + ":" + packethandshakinginsetprotocol.port(); // CraftBukkit  - set hostname
+         switch (packethandshakinginsetprotocol.intention()) {
+             case LOGIN:
+                 this.beginLogin(packethandshakinginsetprotocol, false);
+@@ -59,6 +69,40 @@
+ 
+     private void beginLogin(PacketHandshakingInSetProtocol packethandshakinginsetprotocol, boolean flag) {
+         this.connection.setupOutboundProtocol(LoginProtocols.CLIENTBOUND);
++        // CraftBukkit start - Connection throttle
++        try {
++            long currentTime = System.currentTimeMillis();
++            long connectionThrottle = this.server.server.getConnectionThrottle();
++            InetAddress address = ((java.net.InetSocketAddress) this.connection.getRemoteAddress()).getAddress();
++
++            synchronized (throttleTracker) {
++                if (throttleTracker.containsKey(address) && !"127.0.0.1".equals(address.getHostAddress()) && currentTime - throttleTracker.get(address) < connectionThrottle) {
++                    throttleTracker.put(address, currentTime);
++                    IChatMutableComponent chatmessage = IChatBaseComponent.literal("Connection throttled! Please wait before reconnecting.");
++                    this.connection.send(new PacketLoginOutDisconnect(chatmessage));
++                    this.connection.disconnect(chatmessage);
++                    return;
++                }
++
++                throttleTracker.put(address, currentTime);
++                throttleCounter++;
++                if (throttleCounter > 200) {
++                    throttleCounter = 0;
++
++                    // Cleanup stale entries
++                    java.util.Iterator iter = throttleTracker.entrySet().iterator();
++                    while (iter.hasNext()) {
++                        java.util.Map.Entry<InetAddress, Long> entry = (java.util.Map.Entry) iter.next();
++                        if (entry.getValue() > connectionThrottle) {
++                            iter.remove();
++                        }
++                    }
++                }
++            }
++        } catch (Throwable t) {
++            org.apache.logging.log4j.LogManager.getLogger().debug("Failed to check connection throttle", t);
++        }
++        // CraftBukkit end
+         if (packethandshakinginsetprotocol.protocolVersion() != SharedConstants.getCurrentVersion().getProtocolVersion()) {
+             IChatMutableComponent ichatmutablecomponent;
+ 

paper-server/patches/sources/net/minecraft/server/network/LegacyPingHandler.patch

@@ -0,0 +1,45 @@
+--- a/net/minecraft/server/network/LegacyPingHandler.java
++++ b/net/minecraft/server/network/LegacyPingHandler.java
+@@ -35,10 +35,11 @@
+                 SocketAddress socketaddress = channelhandlercontext.channel().remoteAddress();
+                 int i = bytebuf.readableBytes();
+                 String s;
++                org.bukkit.event.server.ServerListPingEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callServerListPingEvent(socketaddress, server.getMotd(), server.getPlayerCount(), server.getMaxPlayers()); // CraftBukkit
+ 
+                 if (i == 0) {
+                     LegacyPingHandler.LOGGER.debug("Ping: (<1.3.x) from {}", socketaddress);
+-                    s = createVersion0Response(this.server);
++                    s = createVersion0Response(this.server, event); // CraftBukkit
+                     sendFlushAndClose(channelhandlercontext, createLegacyDisconnectPacket(channelhandlercontext.alloc(), s));
+                 } else {
+                     if (bytebuf.readUnsignedByte() != 1) {
+@@ -55,7 +56,7 @@
+                         LegacyPingHandler.LOGGER.debug("Ping: (1.4-1.5.x) from {}", socketaddress);
+                     }
+ 
+-                    s = createVersion1Response(this.server);
++                    s = createVersion1Response(this.server, event); // CraftBukkit
+                     sendFlushAndClose(channelhandlercontext, createLegacyDisconnectPacket(channelhandlercontext.alloc(), s));
+                 }
+ 
+@@ -106,12 +107,16 @@
+         }
+     }
+ 
+-    private static String createVersion0Response(ServerInfo serverinfo) {
+-        return String.format(Locale.ROOT, "%s\u00a7%d\u00a7%d", serverinfo.getMotd(), serverinfo.getPlayerCount(), serverinfo.getMaxPlayers());
++    // CraftBukkit start
++    private static String createVersion0Response(ServerInfo serverinfo, org.bukkit.event.server.ServerListPingEvent event) {
++        return String.format(Locale.ROOT, "%s\u00a7%d\u00a7%d", event.getMotd(), event.getNumPlayers(), event.getMaxPlayers());
++        // CraftBukkit end
+     }
+ 
+-    private static String createVersion1Response(ServerInfo serverinfo) {
+-        return String.format(Locale.ROOT, "\u00a71\u0000%d\u0000%s\u0000%s\u0000%d\u0000%d", 127, serverinfo.getServerVersion(), serverinfo.getMotd(), serverinfo.getPlayerCount(), serverinfo.getMaxPlayers());
++    // CraftBukkit start
++    private static String createVersion1Response(ServerInfo serverinfo, org.bukkit.event.server.ServerListPingEvent event) {
++        return String.format(Locale.ROOT, "\u00a71\u0000%d\u0000%s\u0000%s\u0000%d\u0000%d", 127, serverinfo.getServerVersion(), event.getMotd(), event.getNumPlayers(), event.getMaxPlayers());
++        // CraftBukkit end
+     }
+ 
+     private static void sendFlushAndClose(ChannelHandlerContext channelhandlercontext, ByteBuf bytebuf) {

paper-server/patches/sources/net/minecraft/server/network/LoginListener.patch

@@ -0,0 +1,245 @@
+--- a/net/minecraft/server/network/LoginListener.java
++++ b/net/minecraft/server/network/LoginListener.java
+@@ -44,8 +44,38 @@
+ import org.apache.commons.lang3.Validate;
+ import org.slf4j.Logger;
+ 
+-public class LoginListener implements PacketLoginInListener, TickablePacketListener {
++// CraftBukkit start
++import net.minecraft.network.EnumProtocol;
++import net.minecraft.network.protocol.Packet;
++import net.minecraft.network.protocol.PlayerConnectionUtils;
++import net.minecraft.server.level.EntityPlayer;
++import org.bukkit.craftbukkit.entity.CraftPlayer;
++import org.bukkit.craftbukkit.util.Waitable;
++import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
++import org.bukkit.event.player.PlayerPreLoginEvent;
++
++public class LoginListener implements PacketLoginInListener, TickablePacketListener, CraftPlayer.TransferCookieConnection {
++
++    @Override
++    public boolean isTransferred() {
++        return this.transferred;
++    }
++
++    @Override
++    public EnumProtocol getProtocol() {
++        return EnumProtocol.LOGIN;
++    }
++
++    @Override
++    public void sendPacket(Packet<?> packet) {
++        this.connection.send(packet);
++    }
+ 
++    @Override
++    public void kickPlayer(IChatBaseComponent reason) {
++        disconnect(reason);
++    }
++    // CraftBukkit end
+     private static final AtomicInteger UNIQUE_THREAD_ID = new AtomicInteger(0);
+     static final Logger LOGGER = LogUtils.getLogger();
+     private static final int MAX_TICKS_BEFORE_LOGIN = 600;
+@@ -60,6 +90,7 @@
+     private GameProfile authenticatedProfile;
+     private final String serverId;
+     private final boolean transferred;
++    private EntityPlayer player; // CraftBukkit
+ 
+     public LoginListener(MinecraftServer minecraftserver, NetworkManager networkmanager, boolean flag) {
+         this.state = LoginListener.EnumProtocolState.HELLO;
+@@ -76,6 +107,12 @@
+             this.verifyLoginAndFinishConnectionSetup((GameProfile) Objects.requireNonNull(this.authenticatedProfile));
+         }
+ 
++        // CraftBukkit start
++        if (this.state == LoginListener.EnumProtocolState.WAITING_FOR_COOKIES && !this.player.getBukkitEntity().isAwaitingCookies()) {
++            this.postCookies(this.authenticatedProfile);
++        }
++        // CraftBukkit end
++
+         if (this.state == LoginListener.EnumProtocolState.WAITING_FOR_DUPE_DISCONNECT && !this.isPlayerAlreadyInWorld((GameProfile) Objects.requireNonNull(this.authenticatedProfile))) {
+             this.finishLoginAndWaitForClient(this.authenticatedProfile);
+         }
+@@ -86,6 +123,13 @@
+ 
+     }
+ 
++    // CraftBukkit start
++    @Deprecated
++    public void disconnect(String s) {
++        disconnect(IChatBaseComponent.literal(s));
++    }
++    // CraftBukkit end
++
+     @Override
+     public boolean isAcceptingMessages() {
+         return this.connection.isConnected();
+@@ -131,7 +175,27 @@
+                 this.state = LoginListener.EnumProtocolState.KEY;
+                 this.connection.send(new PacketLoginOutEncryptionBegin("", this.server.getKeyPair().getPublic().getEncoded(), this.challenge, true));
+             } else {
+-                this.startClientVerification(UUIDUtil.createOfflineProfile(this.requestedUsername));
++                // CraftBukkit start
++                Thread thread = new Thread("User Authenticator #" + LoginListener.UNIQUE_THREAD_ID.incrementAndGet()) {
++
++                    @Override
++                    public void run() {
++                        try {
++                            GameProfile gameprofile = UUIDUtil.createOfflineProfile(LoginListener.this.requestedUsername);
++
++                            LoginListener.this.callPlayerPreLoginEvents(gameprofile);
++                            LoginListener.LOGGER.info("UUID of player {} is {}", gameprofile.getName(), gameprofile.getId());
++                            LoginListener.this.startClientVerification(gameprofile);
++                        } catch (Exception ex) {
++                            disconnect("Failed to verify username!");
++                            server.server.getLogger().log(java.util.logging.Level.WARNING, "Exception verifying " + LoginListener.this.requestedUsername, ex);
++                        }
++                    }
++                };
++
++                thread.setUncaughtExceptionHandler(new DefaultUncaughtExceptionHandler(LoginListener.LOGGER));
++                thread.start();
++                // CraftBukkit end
+             }
+ 
+         }
+@@ -144,10 +208,24 @@
+ 
+     private void verifyLoginAndFinishConnectionSetup(GameProfile gameprofile) {
+         PlayerList playerlist = this.server.getPlayerList();
+-        IChatBaseComponent ichatbasecomponent = playerlist.canPlayerLogin(this.connection.getRemoteAddress(), gameprofile);
++        // CraftBukkit start - fire PlayerLoginEvent
++        this.player = playerlist.canPlayerLogin(this, gameprofile); // CraftBukkit
+ 
+-        if (ichatbasecomponent != null) {
+-            this.disconnect(ichatbasecomponent);
++        if (this.player != null) {
++            if (this.player.getBukkitEntity().isAwaitingCookies()) {
++                this.state = LoginListener.EnumProtocolState.WAITING_FOR_COOKIES;
++            } else {
++                this.postCookies(gameprofile);
++            }
++        }
++    }
++
++    private void postCookies(GameProfile gameprofile) {
++        PlayerList playerlist = this.server.getPlayerList();
++
++        if (this.player == null) {
++            // this.disconnect(ichatbasecomponent);
++            // CraftBukkit end
+         } else {
+             if (this.server.getCompressionThreshold() >= 0 && !this.connection.isMemoryConnection()) {
+                 this.connection.send(new PacketLoginOutSetCompression(this.server.getCompressionThreshold()), PacketSendListener.thenRun(() -> {
+@@ -155,7 +233,7 @@
+                 }));
+             }
+ 
+-            boolean flag = playerlist.disconnectAllPlayersWithProfile(gameprofile);
++            boolean flag = playerlist.disconnectAllPlayersWithProfile(gameprofile, this.player); // CraftBukkit - add player reference
+ 
+             if (flag) {
+                 this.state = LoginListener.EnumProtocolState.WAITING_FOR_DUPE_DISCONNECT;
+@@ -205,6 +283,12 @@
+                     if (profileresult != null) {
+                         GameProfile gameprofile = profileresult.profile();
+ 
++                        // CraftBukkit start - fire PlayerPreLoginEvent
++                        if (!connection.isConnected()) {
++                            return;
++                        }
++                        LoginListener.this.callPlayerPreLoginEvents(gameprofile);
++                        // CraftBukkit end
+                         LoginListener.LOGGER.info("UUID of player {} is {}", gameprofile.getName(), gameprofile.getId());
+                         LoginListener.this.startClientVerification(gameprofile);
+                     } else if (LoginListener.this.server.isSingleplayer()) {
+@@ -222,6 +306,11 @@
+                         LoginListener.this.disconnect(IChatBaseComponent.translatable("multiplayer.disconnect.authservers_down"));
+                         LoginListener.LOGGER.error("Couldn't verify username because servers are unavailable");
+                     }
++                    // CraftBukkit start - catch all exceptions
++                } catch (Exception exception) {
++                    disconnect("Failed to verify username!");
++                    server.server.getLogger().log(java.util.logging.Level.WARNING, "Exception verifying " + s1, exception);
++                    // CraftBukkit end
+                 }
+ 
+             }
+@@ -238,6 +327,43 @@
+         thread.start();
+     }
+ 
++    // CraftBukkit start
++    private void callPlayerPreLoginEvents(GameProfile gameprofile) throws Exception {
++        String playerName = gameprofile.getName();
++        java.net.InetAddress address = ((java.net.InetSocketAddress) connection.getRemoteAddress()).getAddress();
++        java.util.UUID uniqueId = gameprofile.getId();
++        final org.bukkit.craftbukkit.CraftServer server = LoginListener.this.server.server;
++
++        AsyncPlayerPreLoginEvent asyncEvent = new AsyncPlayerPreLoginEvent(playerName, address, uniqueId, this.transferred);
++        server.getPluginManager().callEvent(asyncEvent);
++
++        if (PlayerPreLoginEvent.getHandlerList().getRegisteredListeners().length != 0) {
++            final PlayerPreLoginEvent event = new PlayerPreLoginEvent(playerName, address, uniqueId);
++            if (asyncEvent.getResult() != PlayerPreLoginEvent.Result.ALLOWED) {
++                event.disallow(asyncEvent.getResult(), asyncEvent.getKickMessage());
++            }
++            Waitable<PlayerPreLoginEvent.Result> waitable = new Waitable<PlayerPreLoginEvent.Result>() {
++                @Override
++                protected PlayerPreLoginEvent.Result evaluate() {
++                    server.getPluginManager().callEvent(event);
++                    return event.getResult();
++                }
++            };
++
++            LoginListener.this.server.processQueue.add(waitable);
++            if (waitable.get() != PlayerPreLoginEvent.Result.ALLOWED) {
++                disconnect(event.getKickMessage());
++                return;
++            }
++        } else {
++            if (asyncEvent.getLoginResult() != AsyncPlayerPreLoginEvent.Result.ALLOWED) {
++                disconnect(asyncEvent.getKickMessage());
++                return;
++            }
++        }
++    }
++    // CraftBukkit end
++
+     @Override
+     public void handleCustomQueryPacket(ServerboundCustomQueryAnswerPacket serverboundcustomqueryanswerpacket) {
+         this.disconnect(ServerCommonPacketListenerImpl.DISCONNECT_UNEXPECTED_QUERY);
+@@ -245,10 +371,11 @@
+ 
+     @Override
+     public void handleLoginAcknowledgement(ServerboundLoginAcknowledgedPacket serverboundloginacknowledgedpacket) {
++        PlayerConnectionUtils.ensureRunningOnSameThread(serverboundloginacknowledgedpacket, this, this.server); // CraftBukkit
+         Validate.validState(this.state == LoginListener.EnumProtocolState.PROTOCOL_SWITCHING, "Unexpected login acknowledgement packet", new Object[0]);
+         this.connection.setupOutboundProtocol(ConfigurationProtocols.CLIENTBOUND);
+         CommonListenerCookie commonlistenercookie = CommonListenerCookie.createInitial((GameProfile) Objects.requireNonNull(this.authenticatedProfile), this.transferred);
+-        ServerConfigurationPacketListenerImpl serverconfigurationpacketlistenerimpl = new ServerConfigurationPacketListenerImpl(this.server, this.connection, commonlistenercookie);
++        ServerConfigurationPacketListenerImpl serverconfigurationpacketlistenerimpl = new ServerConfigurationPacketListenerImpl(this.server, this.connection, commonlistenercookie, this.player); // CraftBukkit
+ 
+         this.connection.setupInboundProtocol(ConfigurationProtocols.SERVERBOUND, serverconfigurationpacketlistenerimpl);
+         serverconfigurationpacketlistenerimpl.startConfiguration();
+@@ -264,12 +391,18 @@
+ 
+     @Override
+     public void handleCookieResponse(ServerboundCookieResponsePacket serverboundcookieresponsepacket) {
++        // CraftBukkit start
++        PlayerConnectionUtils.ensureRunningOnSameThread(serverboundcookieresponsepacket, this, this.server);
++        if (this.player != null && this.player.getBukkitEntity().handleCookieResponse(serverboundcookieresponsepacket)) {
++            return;
++        }
++        // CraftBukkit end
+         this.disconnect(ServerCommonPacketListenerImpl.DISCONNECT_UNEXPECTED_QUERY);
+     }
+ 
+     private static enum EnumProtocolState {
+ 
+-        HELLO, KEY, AUTHENTICATING, NEGOTIATING, VERIFYING, WAITING_FOR_DUPE_DISCONNECT, PROTOCOL_SWITCHING, ACCEPTED;
++        HELLO, KEY, AUTHENTICATING, NEGOTIATING, VERIFYING, WAITING_FOR_COOKIES, WAITING_FOR_DUPE_DISCONNECT, PROTOCOL_SWITCHING, ACCEPTED; // CraftBukkit
+ 
+         private EnumProtocolState() {}
+     }

paper-server/patches/sources/net/minecraft/server/network/PacketStatusListener.patch

@@ -0,0 +1,127 @@
+--- a/net/minecraft/server/network/PacketStatusListener.java
++++ b/net/minecraft/server/network/PacketStatusListener.java
+@@ -10,6 +10,21 @@
+ import net.minecraft.network.protocol.status.PacketStatusOutServerInfo;
+ import net.minecraft.network.protocol.status.ServerPing;
+ 
++// CraftBukkit start
++import com.mojang.authlib.GameProfile;
++import java.net.InetSocketAddress;
++import java.util.Collections;
++import java.util.Iterator;
++import java.util.Optional;
++import net.minecraft.SharedConstants;
++import net.minecraft.network.protocol.status.ServerPing;
++import net.minecraft.server.MinecraftServer;
++import net.minecraft.server.level.EntityPlayer;
++import org.bukkit.craftbukkit.util.CraftChatMessage;
++import org.bukkit.craftbukkit.util.CraftIconCache;
++import org.bukkit.entity.Player;
++// CraftBukkit end
++
+ public class PacketStatusListener implements PacketStatusInListener {
+ 
+     private static final IChatBaseComponent DISCONNECT_REASON = IChatBaseComponent.translatable("multiplayer.status.request_handled");
+@@ -36,7 +51,101 @@
+             this.connection.disconnect(PacketStatusListener.DISCONNECT_REASON);
+         } else {
+             this.hasRequestedStatus = true;
+-            this.connection.send(new PacketStatusOutServerInfo(this.status));
++            // CraftBukkit start
++            // this.connection.send(new PacketStatusOutServerInfo(this.status));
++            MinecraftServer server = MinecraftServer.getServer();
++            final Object[] players = server.getPlayerList().players.toArray();
++            class ServerListPingEvent extends org.bukkit.event.server.ServerListPingEvent {
++
++                CraftIconCache icon = server.server.getServerIcon();
++
++                ServerListPingEvent() {
++                    super(connection.hostname, ((InetSocketAddress) connection.getRemoteAddress()).getAddress(), server.getMotd(), server.getPlayerList().getMaxPlayers());
++                }
++
++                @Override
++                public void setServerIcon(org.bukkit.util.CachedServerIcon icon) {
++                    if (!(icon instanceof CraftIconCache)) {
++                        throw new IllegalArgumentException(icon + " was not created by " + org.bukkit.craftbukkit.CraftServer.class);
++                    }
++                    this.icon = (CraftIconCache) icon;
++                }
++
++                @Override
++                public Iterator<Player> iterator() throws UnsupportedOperationException {
++                    return new Iterator<Player>() {
++                        int i;
++                        int ret = Integer.MIN_VALUE;
++                        EntityPlayer player;
++
++                        @Override
++                        public boolean hasNext() {
++                            if (player != null) {
++                                return true;
++                            }
++                            final Object[] currentPlayers = players;
++                            for (int length = currentPlayers.length, i = this.i; i < length; i++) {
++                                final EntityPlayer player = (EntityPlayer) currentPlayers[i];
++                                if (player != null) {
++                                    this.i = i + 1;
++                                    this.player = player;
++                                    return true;
++                                }
++                            }
++                            return false;
++                        }
++
++                        @Override
++                        public Player next() {
++                            if (!hasNext()) {
++                                throw new java.util.NoSuchElementException();
++                            }
++                            final EntityPlayer player = this.player;
++                            this.player = null;
++                            this.ret = this.i - 1;
++                            return player.getBukkitEntity();
++                        }
++
++                        @Override
++                        public void remove() {
++                            final Object[] currentPlayers = players;
++                            final int i = this.ret;
++                            if (i < 0 || currentPlayers[i] == null) {
++                                throw new IllegalStateException();
++                            }
++                            currentPlayers[i] = null;
++                        }
++                    };
++                }
++            }
++
++            ServerListPingEvent event = new ServerListPingEvent();
++            server.server.getPluginManager().callEvent(event);
++
++            java.util.List<GameProfile> profiles = new java.util.ArrayList<GameProfile>(players.length);
++            for (Object player : players) {
++                if (player != null) {
++                    EntityPlayer entityPlayer = ((EntityPlayer) player);
++                    if (entityPlayer.allowsListing()) {
++                        profiles.add(entityPlayer.getGameProfile());
++                    } else {
++                        profiles.add(MinecraftServer.ANONYMOUS_PLAYER_PROFILE);
++                    }
++                }
++            }
++
++            ServerPing.ServerPingPlayerSample playerSample = new ServerPing.ServerPingPlayerSample(event.getMaxPlayers(), event.getNumPlayers(), (server.hidesOnlinePlayers()) ? Collections.emptyList() : profiles);
++
++            ServerPing ping = new ServerPing(
++                    CraftChatMessage.fromString(event.getMotd(), true)[0],
++                    Optional.of(playerSample),
++                    Optional.of(new ServerPing.ServerData(server.getServerModName() + " " + server.getServerVersion(), SharedConstants.getCurrentVersion().getProtocolVersion())),
++                    (event.icon.value != null) ? Optional.of(new ServerPing.a(event.icon.value)) : Optional.empty(),
++                    server.enforceSecureProfile()
++            );
++
++            this.connection.send(new PacketStatusOutServerInfo(ping));
++            // CraftBukkit end
+         }
+     }
+ 

paper-server/patches/sources/net/minecraft/server/network/ServerCommonPacketListenerImpl.patch

@@ -0,0 +1,246 @@
+--- a/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
++++ b/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+@@ -29,8 +29,44 @@
+ import net.minecraft.util.thread.IAsyncTaskHandler;
+ import org.slf4j.Logger;
+ 
+-public abstract class ServerCommonPacketListenerImpl implements ServerCommonPacketListener {
++// CraftBukkit start
++import io.netty.buffer.ByteBuf;
++import java.util.concurrent.ExecutionException;
++import net.minecraft.EnumChatFormat;
++import net.minecraft.network.EnumProtocol;
++import net.minecraft.network.protocol.common.custom.DiscardedPayload;
++import net.minecraft.network.protocol.game.PacketPlayOutSpawnPosition;
++import net.minecraft.resources.MinecraftKey;
++import net.minecraft.server.level.EntityPlayer;
++import org.bukkit.craftbukkit.entity.CraftPlayer;
++import org.bukkit.craftbukkit.util.CraftChatMessage;
++import org.bukkit.craftbukkit.util.CraftLocation;
++import org.bukkit.craftbukkit.util.Waitable;
++import org.bukkit.event.player.PlayerKickEvent;
++import org.bukkit.event.player.PlayerResourcePackStatusEvent;
++
++public abstract class ServerCommonPacketListenerImpl implements ServerCommonPacketListener, CraftPlayer.TransferCookieConnection {
++
++    @Override
++    public boolean isTransferred() {
++        return this.transferred;
++    }
+ 
++    @Override
++    public EnumProtocol getProtocol() {
++        return protocol();
++    }
++
++    @Override
++    public void sendPacket(Packet<?> packet) {
++        send(packet);
++    }
++
++    @Override
++    public void kickPlayer(IChatBaseComponent reason) {
++        disconnect(reason);
++    }
++    // CraftBukkit end
+     private static final Logger LOGGER = LogUtils.getLogger();
+     public static final int LATENCY_CHECK_INTERVAL = 15000;
+     private static final int CLOSED_LISTENER_TIMEOUT = 15000;
+@@ -47,12 +83,24 @@
+     private int latency;
+     private volatile boolean suspendFlushingOnServerThread = false;
+ 
+-    public ServerCommonPacketListenerImpl(MinecraftServer minecraftserver, NetworkManager networkmanager, CommonListenerCookie commonlistenercookie) {
++    public ServerCommonPacketListenerImpl(MinecraftServer minecraftserver, NetworkManager networkmanager, CommonListenerCookie commonlistenercookie, EntityPlayer player) { // CraftBukkit
+         this.server = minecraftserver;
+         this.connection = networkmanager;
+         this.keepAliveTime = SystemUtils.getMillis();
+         this.latency = commonlistenercookie.latency();
+         this.transferred = commonlistenercookie.transferred();
++        // CraftBukkit start - add fields and methods
++        this.player = player;
++        this.player.transferCookieConnection = this;
++        this.cserver = minecraftserver.server;
++    }
++    protected final EntityPlayer player;
++    protected final org.bukkit.craftbukkit.CraftServer cserver;
++    public boolean processedDisconnect;
++
++    public CraftPlayer getCraftPlayer() {
++        return (this.player == null) ? null : (CraftPlayer) this.player.getBukkitEntity();
++        // CraftBukkit end
+     }
+ 
+     private void close() {
+@@ -80,6 +128,7 @@
+ 
+     @Override
+     public void handleKeepAlive(ServerboundKeepAlivePacket serverboundkeepalivepacket) {
++        PlayerConnectionUtils.ensureRunningOnSameThread(serverboundkeepalivepacket, this, this.player.serverLevel()); // CraftBukkit
+         if (this.keepAlivePending && serverboundkeepalivepacket.getId() == this.keepAliveChallenge) {
+             int i = (int) (SystemUtils.getMillis() - this.keepAliveTime);
+ 
+@@ -94,8 +143,56 @@
+     @Override
+     public void handlePong(ServerboundPongPacket serverboundpongpacket) {}
+ 
++    // CraftBukkit start
++    private static final MinecraftKey CUSTOM_REGISTER = MinecraftKey.withDefaultNamespace("register");
++    private static final MinecraftKey CUSTOM_UNREGISTER = MinecraftKey.withDefaultNamespace("unregister");
++
+     @Override
+-    public void handleCustomPayload(ServerboundCustomPayloadPacket serverboundcustompayloadpacket) {}
++    public void handleCustomPayload(ServerboundCustomPayloadPacket serverboundcustompayloadpacket) {
++        if (!(serverboundcustompayloadpacket.payload() instanceof DiscardedPayload)) {
++            return;
++        }
++        PlayerConnectionUtils.ensureRunningOnSameThread(serverboundcustompayloadpacket, this, this.player.serverLevel());
++        MinecraftKey identifier = serverboundcustompayloadpacket.payload().type().id();
++        ByteBuf payload = ((DiscardedPayload)serverboundcustompayloadpacket.payload()).data();
++
++        if (identifier.equals(CUSTOM_REGISTER)) {
++            try {
++                String channels = payload.toString(com.google.common.base.Charsets.UTF_8);
++                for (String channel : channels.split("\0")) {
++                    getCraftPlayer().addChannel(channel);
++                }
++            } catch (Exception ex) {
++                PlayerConnection.LOGGER.error("Couldn\'t register custom payload", ex);
++                this.disconnect(IChatBaseComponent.literal("Invalid payload REGISTER!"));
++            }
++        } else if (identifier.equals(CUSTOM_UNREGISTER)) {
++            try {
++                String channels = payload.toString(com.google.common.base.Charsets.UTF_8);
++                for (String channel : channels.split("\0")) {
++                    getCraftPlayer().removeChannel(channel);
++                }
++            } catch (Exception ex) {
++                PlayerConnection.LOGGER.error("Couldn\'t unregister custom payload", ex);
++                this.disconnect(IChatBaseComponent.literal("Invalid payload UNREGISTER!"));
++            }
++        } else {
++            try {
++                byte[] data = new byte[payload.readableBytes()];
++                payload.readBytes(data);
++                cserver.getMessenger().dispatchIncomingMessage(player.getBukkitEntity(), identifier.toString(), data);
++            } catch (Exception ex) {
++                PlayerConnection.LOGGER.error("Couldn\'t dispatch custom payload", ex);
++                this.disconnect(IChatBaseComponent.literal("Invalid custom payload!"));
++            }
++        }
++
++    }
++
++    public final boolean isDisconnected() {
++        return !this.player.joining && !this.connection.isConnected();
++    }
++    // CraftBukkit end
+ 
+     @Override
+     public void handleResourcePackResponse(ServerboundResourcePackPacket serverboundresourcepackpacket) {
+@@ -104,11 +201,18 @@
+             ServerCommonPacketListenerImpl.LOGGER.info("Disconnecting {} due to resource pack {} rejection", this.playerProfile().getName(), serverboundresourcepackpacket.id());
+             this.disconnect((IChatBaseComponent) IChatBaseComponent.translatable("multiplayer.requiredTexturePrompt.disconnect"));
+         }
++        this.cserver.getPluginManager().callEvent(new PlayerResourcePackStatusEvent(getCraftPlayer(), serverboundresourcepackpacket.id(), PlayerResourcePackStatusEvent.Status.values()[serverboundresourcepackpacket.action().ordinal()])); // CraftBukkit
+ 
+     }
+ 
+     @Override
+     public void handleCookieResponse(ServerboundCookieResponsePacket serverboundcookieresponsepacket) {
++        // CraftBukkit start
++        PlayerConnectionUtils.ensureRunningOnSameThread(serverboundcookieresponsepacket, this, (IAsyncTaskHandler) this.server);
++        if (this.player.getBukkitEntity().handleCookieResponse(serverboundcookieresponsepacket)) {
++            return;
++        }
++        // CraftBukkit end
+         this.disconnect(ServerCommonPacketListenerImpl.DISCONNECT_UNEXPECTED_QUERY);
+     }
+ 
+@@ -116,7 +220,7 @@
+         Profiler.get().push("keepAlive");
+         long i = SystemUtils.getMillis();
+ 
+-        if (!this.isSingleplayerOwner() && i - this.keepAliveTime >= 15000L) {
++        if (!this.isSingleplayerOwner() && i - this.keepAliveTime >= 25000L) { // CraftBukkit
+             if (this.keepAlivePending) {
+                 this.disconnect(ServerCommonPacketListenerImpl.TIMEOUT_DISCONNECTION_MESSAGE);
+             } else if (this.checkIfClosed(i)) {
+@@ -156,6 +260,14 @@
+     }
+ 
+     public void send(Packet<?> packet, @Nullable PacketSendListener packetsendlistener) {
++        // CraftBukkit start
++        if (packet == null) {
++            return;
++        } else if (packet instanceof PacketPlayOutSpawnPosition) {
++            PacketPlayOutSpawnPosition packet6 = (PacketPlayOutSpawnPosition) packet;
++            this.player.compassTarget = CraftLocation.toBukkit(packet6.pos, this.getCraftPlayer().getWorld());
++        }
++        // CraftBukkit end
+         if (packet.isTerminal()) {
+             this.close();
+         }
+@@ -180,15 +292,61 @@
+     }
+ 
+     public void disconnect(DisconnectionDetails disconnectiondetails) {
++        // CraftBukkit start - fire PlayerKickEvent
++        if (this.processedDisconnect) {
++            return;
++        }
++        if (!this.cserver.isPrimaryThread()) {
++            Waitable waitable = new Waitable() {
++                @Override
++                protected Object evaluate() {
++                    ServerCommonPacketListenerImpl.this.disconnect(disconnectiondetails);
++                    return null;
++                }
++            };
++
++            this.server.processQueue.add(waitable);
++
++            try {
++                waitable.get();
++            } catch (InterruptedException e) {
++                Thread.currentThread().interrupt();
++            } catch (ExecutionException e) {
++                throw new RuntimeException(e);
++            }
++            return;
++        }
++
++        String leaveMessage = EnumChatFormat.YELLOW + this.player.getScoreboardName() + " left the game.";
++
++        PlayerKickEvent event = new PlayerKickEvent(this.player.getBukkitEntity(), CraftChatMessage.fromComponent(disconnectiondetails.reason()), leaveMessage);
++
++        if (this.cserver.getServer().isRunning()) {
++            this.cserver.getPluginManager().callEvent(event);
++        }
++
++        if (event.isCancelled()) {
++            // Do not kick the player
++            return;
++        }
++        this.player.kickLeaveMessage = event.getLeaveMessage(); // CraftBukkit - SPIGOT-3034: Forward leave message to PlayerQuitEvent
++        // Send the possibly modified leave message
++        disconnect0(new DisconnectionDetails(CraftChatMessage.fromString(event.getReason(), true)[0], disconnectiondetails.report(), disconnectiondetails.bugReportLink()));
++    }
++
++    private void disconnect0(DisconnectionDetails disconnectiondetails) {
++        // CraftBukkit end
+         this.connection.send(new ClientboundDisconnectPacket(disconnectiondetails.reason()), PacketSendListener.thenRun(() -> {
+             this.connection.disconnect(disconnectiondetails);
+         }));
++        this.onDisconnect(disconnectiondetails); // CraftBukkit - fire quit instantly
+         this.connection.setReadOnly();
+         MinecraftServer minecraftserver = this.server;
+         NetworkManager networkmanager = this.connection;
+ 
+         Objects.requireNonNull(this.connection);
+-        minecraftserver.executeBlocking(networkmanager::handleDisconnection);
++        // CraftBukkit - Don't wait
++        minecraftserver.wrapRunnable(networkmanager::handleDisconnection);
+     }
+ 
+     protected boolean isSingleplayerOwner() {

paper-server/patches/sources/net/minecraft/server/network/ServerConfigurationPacketListenerImpl.patch

@@ -0,0 +1,57 @@
+--- a/net/minecraft/server/network/ServerConfigurationPacketListenerImpl.java
++++ b/net/minecraft/server/network/ServerConfigurationPacketListenerImpl.java
+@@ -38,6 +38,11 @@
+ import net.minecraft.world.flag.FeatureFlags;
+ import org.slf4j.Logger;
+ 
++// CraftBukkit start
++import org.bukkit.craftbukkit.CraftServerLinks;
++import org.bukkit.event.player.PlayerLinksSendEvent;
++// CraftBukkit end
++
+ public class ServerConfigurationPacketListenerImpl extends ServerCommonPacketListenerImpl implements ServerConfigurationPacketListener, TickablePacketListener {
+ 
+     private static final Logger LOGGER = LogUtils.getLogger();
+@@ -50,8 +55,10 @@
+     @Nullable
+     private SynchronizeRegistriesTask synchronizeRegistriesTask;
+ 
+-    public ServerConfigurationPacketListenerImpl(MinecraftServer minecraftserver, NetworkManager networkmanager, CommonListenerCookie commonlistenercookie) {
+-        super(minecraftserver, networkmanager, commonlistenercookie);
++    // CraftBukkit start
++    public ServerConfigurationPacketListenerImpl(MinecraftServer minecraftserver, NetworkManager networkmanager, CommonListenerCookie commonlistenercookie, EntityPlayer player) {
++        super(minecraftserver, networkmanager, commonlistenercookie, player);
++        // CraftBukkit end
+         this.gameProfile = commonlistenercookie.gameProfile();
+         this.clientInformation = commonlistenercookie.clientInformation();
+     }
+@@ -75,6 +82,12 @@
+     public void startConfiguration() {
+         this.send(new ClientboundCustomPayloadPacket(new BrandPayload(this.server.getServerModName())));
+         ServerLinks serverlinks = this.server.serverLinks();
++        // CraftBukkit start
++        CraftServerLinks wrapper = new CraftServerLinks(serverlinks);
++        PlayerLinksSendEvent event = new PlayerLinksSendEvent(player.getBukkitEntity(), wrapper);
++        player.getBukkitEntity().getServer().getPluginManager().callEvent(event);
++        serverlinks = wrapper.getServerLinks();
++        // CraftBukkit end
+ 
+         if (!serverlinks.isEmpty()) {
+             this.send(new ClientboundServerLinksPacket(serverlinks.untrust()));
+@@ -143,14 +156,14 @@
+                 return;
+             }
+ 
+-            IChatBaseComponent ichatbasecomponent = playerlist.canPlayerLogin(this.connection.getRemoteAddress(), this.gameProfile);
++            IChatBaseComponent ichatbasecomponent = null; // CraftBukkit - login checks already completed
+ 
+             if (ichatbasecomponent != null) {
+                 this.disconnect(ichatbasecomponent);
+                 return;
+             }
+ 
+-            EntityPlayer entityplayer = playerlist.getPlayerForLogin(this.gameProfile, this.clientInformation);
++            EntityPlayer entityplayer = playerlist.getPlayerForLogin(this.gameProfile, this.clientInformation, this.player); // CraftBukkit
+ 
+             playerlist.placeNewPlayer(this.connection, entityplayer, this.createCookie(this.clientInformation));
+         } catch (Exception exception) {

paper-server/patches/sources/net/minecraft/server/network/ServerConnection.patch

@@ -0,0 +1,30 @@
+--- a/net/minecraft/server/network/ServerConnection.java
++++ b/net/minecraft/server/network/ServerConnection.java
+@@ -100,15 +100,25 @@
+ 
+                     NetworkManager.configureSerialization(channelpipeline, EnumProtocolDirection.SERVERBOUND, false, (BandwidthDebugMonitor) null);
+                     int j = ServerConnection.this.server.getRateLimitPacketsPerSecond();
+-                    Object object = j > 0 ? new NetworkManagerServer(j) : new NetworkManager(EnumProtocolDirection.SERVERBOUND);
++                    NetworkManager object = j > 0 ? new NetworkManagerServer(j) : new NetworkManager(EnumProtocolDirection.SERVERBOUND); // CraftBukkit - decompile error
+ 
+                     ServerConnection.this.connections.add(object);
+                     ((NetworkManager) object).configurePacketHandler(channelpipeline);
+                     ((NetworkManager) object).setListenerForServerboundHandshake(new HandshakeListener(ServerConnection.this.server, (NetworkManager) object));
+                 }
+-            }).group(eventloopgroup).localAddress(inetaddress, i)).bind().syncUninterruptibly());
++            }).group(eventloopgroup).localAddress(inetaddress, i)).option(ChannelOption.AUTO_READ, false).bind().syncUninterruptibly()); // CraftBukkit
++        }
++    }
++
++    // CraftBukkit start
++    public void acceptConnections() {
++        synchronized (this.channels) {
++            for (ChannelFuture future : this.channels) {
++                future.channel().config().setAutoRead(true);
++            }
+         }
+     }
++    // CraftBukkit end
+ 
+     public SocketAddress startMemoryChannel() {
+         List list = this.channels;

paper-server/patches/sources/net/minecraft/server/players/ExpirableListEntry.patch

@@ -0,0 +1,34 @@
+--- a/net/minecraft/server/players/ExpirableListEntry.java
++++ b/net/minecraft/server/players/ExpirableListEntry.java
+@@ -27,7 +27,7 @@
+     }
+ 
+     protected ExpirableListEntry(@Nullable T t0, JsonObject jsonobject) {
+-        super(t0);
++        super(checkExpiry(t0, jsonobject)); // CraftBukkit
+ 
+         Date date;
+ 
+@@ -83,4 +83,22 @@
+         jsonobject.addProperty("expires", this.expires == null ? "forever" : ExpirableListEntry.DATE_FORMAT.format(this.expires));
+         jsonobject.addProperty("reason", this.reason);
+     }
++
++    // CraftBukkit start
++    private static <T> T checkExpiry(T object, JsonObject jsonobject) {
++        Date expires = null;
++
++        try {
++            expires = jsonobject.has("expires") ? DATE_FORMAT.parse(jsonobject.get("expires").getAsString()) : null;
++        } catch (ParseException ex) {
++            // Guess we don't have a date
++        }
++
++        if (expires == null || expires.after(new Date())) {
++            return object;
++        } else {
++            return null;
++        }
++    }
++    // CraftBukkit end
+ }

paper-server/patches/sources/net/minecraft/server/players/GameProfileBanEntry.patch

@@ -0,0 +1,7 @@
+--- a/net/minecraft/server/players/GameProfileBanEntry.java
++++ b/net/minecraft/server/players/GameProfileBanEntry.java
+@@ -1,3 +1,4 @@
++// mc-dev import
+ package net.minecraft.server.players;
+ 
+ import com.google.gson.JsonObject;

paper-server/patches/sources/net/minecraft/server/players/JsonList.patch

@@ -0,0 +1,55 @@
+--- a/net/minecraft/server/players/JsonList.java
++++ b/net/minecraft/server/players/JsonList.java
+@@ -54,7 +54,7 @@
+     @Nullable
+     public V get(K k0) {
+         this.removeExpired();
+-        return (JsonListEntry) this.map.get(this.getKeyForUser(k0));
++        return (V) this.map.get(this.getKeyForUser(k0)); // CraftBukkit - fix decompile error
+     }
+ 
+     public void remove(K k0) {
+@@ -85,6 +85,7 @@
+     }
+ 
+     protected boolean contains(K k0) {
++        this.removeExpired(); // CraftBukkit - SPIGOT-7589: Consistently remove expired entries to mirror .get(...)
+         return this.map.containsKey(this.getKeyForUser(k0));
+     }
+ 
+@@ -93,7 +94,7 @@
+         Iterator iterator = this.map.values().iterator();
+ 
+         while (iterator.hasNext()) {
+-            V v0 = (JsonListEntry) iterator.next();
++            V v0 = (V) iterator.next(); // CraftBukkit - decompile error
+ 
+             if (v0.hasExpired()) {
+                 list.add(v0.getUser());
+@@ -103,7 +104,7 @@
+         iterator = list.iterator();
+ 
+         while (iterator.hasNext()) {
+-            K k0 = iterator.next();
++            K k0 = (K) iterator.next(); // CraftBukkit - decompile error
+ 
+             this.map.remove(this.getKeyForUser(k0));
+         }
+@@ -118,7 +119,7 @@
+ 
+     public void save() throws IOException {
+         JsonArray jsonarray = new JsonArray();
+-        Stream stream = this.map.values().stream().map((jsonlistentry) -> {
++        Stream<JsonObject> stream = this.map.values().stream().map((jsonlistentry) -> { // CraftBukkit - decompile error
+             JsonObject jsonobject = new JsonObject();
+ 
+             Objects.requireNonNull(jsonlistentry);
+@@ -171,7 +172,7 @@
+                         JsonListEntry<K> jsonlistentry = this.createEntry(jsonobject);
+ 
+                         if (jsonlistentry.getUser() != null) {
+-                            this.map.put(this.getKeyForUser(jsonlistentry.getUser()), jsonlistentry);
++                            this.map.put(this.getKeyForUser(jsonlistentry.getUser()), (V) jsonlistentry); // CraftBukkit - decompile error
+                         }
+                     }
+                 } catch (Throwable throwable) {

paper-server/patches/sources/net/minecraft/server/players/NameReferencingFileConverter.patch

@@ -0,0 +1,82 @@
+--- a/net/minecraft/server/players/NameReferencingFileConverter.java
++++ b/net/minecraft/server/players/NameReferencingFileConverter.java
+@@ -27,6 +27,12 @@
+ import net.minecraft.world.level.storage.SavedFile;
+ import org.slf4j.Logger;
+ 
++// CraftBukkit start
++import net.minecraft.nbt.NBTCompressedStreamTools;
++import net.minecraft.nbt.NBTReadLimiter;
++import net.minecraft.nbt.NBTTagCompound;
++// CraftBukkit end
++
+ public class NameReferencingFileConverter {
+ 
+     static final Logger LOGGER = LogUtils.getLogger();
+@@ -85,7 +91,7 @@
+                 try {
+                     gameprofilebanlist.load();
+                 } catch (IOException ioexception) {
+-                    NameReferencingFileConverter.LOGGER.warn("Could not load existing file {}", gameprofilebanlist.getFile().getName(), ioexception);
++                    NameReferencingFileConverter.LOGGER.warn("Could not load existing file {}", gameprofilebanlist.getFile().getName()); // CraftBukkit - don't print stacktrace
+                 }
+             }
+ 
+@@ -143,7 +149,7 @@
+                 try {
+                     ipbanlist.load();
+                 } catch (IOException ioexception) {
+-                    NameReferencingFileConverter.LOGGER.warn("Could not load existing file {}", ipbanlist.getFile().getName(), ioexception);
++                    NameReferencingFileConverter.LOGGER.warn("Could not load existing file {}", ipbanlist.getFile().getName()); // CraftBukkit - don't print stacktrace
+                 }
+             }
+ 
+@@ -184,7 +190,7 @@
+                 try {
+                     oplist.load();
+                 } catch (IOException ioexception) {
+-                    NameReferencingFileConverter.LOGGER.warn("Could not load existing file {}", oplist.getFile().getName(), ioexception);
++                    NameReferencingFileConverter.LOGGER.warn("Could not load existing file {}", oplist.getFile().getName()); // CraftBukkit - don't print stacktrace
+                 }
+             }
+ 
+@@ -228,7 +234,7 @@
+                 try {
+                     whitelist.load();
+                 } catch (IOException ioexception) {
+-                    NameReferencingFileConverter.LOGGER.warn("Could not load existing file {}", whitelist.getFile().getName(), ioexception);
++                    NameReferencingFileConverter.LOGGER.warn("Could not load existing file {}", whitelist.getFile().getName()); // CraftBukkit - don't print stacktrace
+                 }
+             }
+ 
+@@ -347,6 +353,30 @@
+                         File file5 = new File(file, s2 + ".dat");
+                         File file6 = new File(file4, s3 + ".dat");
+ 
++                        // CraftBukkit start - Use old file name to seed lastKnownName
++                        NBTTagCompound root = null;
++
++                        try {
++                            root = NBTCompressedStreamTools.readCompressed(new java.io.FileInputStream(file5), NBTReadLimiter.unlimitedHeap());
++                        } catch (Exception exception) {
++                            exception.printStackTrace();
++                        }
++
++                        if (root != null) {
++                            if (!root.contains("bukkit")) {
++                                root.put("bukkit", new NBTTagCompound());
++                            }
++                            NBTTagCompound data = root.getCompound("bukkit");
++                            data.putString("lastKnownName", s2);
++
++                            try {
++                                NBTCompressedStreamTools.writeCompressed(root, new java.io.FileOutputStream(file2));
++                            } catch (Exception exception) {
++                                exception.printStackTrace();
++                            }
++                       }
++                        // CraftBukkit end
++
+                         NameReferencingFileConverter.ensureDirectoryExists(file4);
+                         if (!file5.renameTo(file6)) {
+                             throw new NameReferencingFileConverter.FileConversionException("Could not convert file for " + s2);

paper-server/patches/sources/net/minecraft/server/players/PlayerList.patch

@@ -0,0 +1,798 @@
+--- a/net/minecraft/server/players/PlayerList.java
++++ b/net/minecraft/server/players/PlayerList.java
+@@ -104,6 +104,27 @@
+ import net.minecraft.world.scores.ScoreboardTeam;
+ import org.slf4j.Logger;
+ 
++// CraftBukkit start
++import java.util.stream.Collectors;
++import net.minecraft.server.dedicated.DedicatedServer;
++import net.minecraft.server.network.LoginListener;
++import org.bukkit.Location;
++import org.bukkit.craftbukkit.CraftServer;
++import org.bukkit.craftbukkit.CraftWorld;
++import org.bukkit.craftbukkit.entity.CraftPlayer;
++import org.bukkit.craftbukkit.util.CraftChatMessage;
++import org.bukkit.craftbukkit.util.CraftLocation;
++import org.bukkit.entity.Player;
++import org.bukkit.event.entity.EntityRemoveEvent;
++import org.bukkit.event.player.PlayerChangedWorldEvent;
++import org.bukkit.event.player.PlayerJoinEvent;
++import org.bukkit.event.player.PlayerLoginEvent;
++import org.bukkit.event.player.PlayerQuitEvent;
++import org.bukkit.event.player.PlayerRespawnEvent;
++import org.bukkit.event.player.PlayerRespawnEvent.RespawnReason;
++import org.bukkit.event.player.PlayerSpawnChangeEvent;
++// CraftBukkit end
++
+ public abstract class PlayerList {
+ 
+     public static final File USERBANLIST_FILE = new File("banned-players.json");
+@@ -116,14 +137,16 @@
+     private static final int SEND_PLAYER_INFO_INTERVAL = 600;
+     private static final SimpleDateFormat BAN_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd 'at' HH:mm:ss z");
+     private final MinecraftServer server;
+-    public final List<EntityPlayer> players = Lists.newArrayList();
++    public final List<EntityPlayer> players = new java.util.concurrent.CopyOnWriteArrayList(); // CraftBukkit - ArrayList -> CopyOnWriteArrayList: Iterator safety
+     private final Map<UUID, EntityPlayer> playersByUUID = Maps.newHashMap();
+     private final GameProfileBanList bans;
+     private final IpBanList ipBans;
+     private final OpList ops;
+     private final WhiteList whitelist;
+-    private final Map<UUID, ServerStatisticManager> stats;
+-    private final Map<UUID, AdvancementDataPlayer> advancements;
++    // CraftBukkit start
++    // private final Map<UUID, ServerStatisticManager> stats;
++    // private final Map<UUID, AdvancementDataPlayer> advancements;
++    // CraftBukkit end
+     public final WorldNBTStorage playerIo;
+     private boolean doWhiteList;
+     private final LayeredRegistryAccess<RegistryLayer> registries;
+@@ -134,13 +157,23 @@
+     private static final boolean ALLOW_LOGOUTIVATOR = false;
+     private int sendAllPlayerInfoIn;
+ 
++    // CraftBukkit start
++    private CraftServer cserver;
++
+     public PlayerList(MinecraftServer minecraftserver, LayeredRegistryAccess<RegistryLayer> layeredregistryaccess, WorldNBTStorage worldnbtstorage, int i) {
++        this.cserver = minecraftserver.server = new CraftServer((DedicatedServer) minecraftserver, this);
++        minecraftserver.console = org.bukkit.craftbukkit.command.ColouredConsoleSender.getInstance();
++        minecraftserver.reader.addCompleter(new org.bukkit.craftbukkit.command.ConsoleCommandCompleter(minecraftserver.server));
++        // CraftBukkit end
++
+         this.bans = new GameProfileBanList(PlayerList.USERBANLIST_FILE);
+         this.ipBans = new IpBanList(PlayerList.IPBANLIST_FILE);
+         this.ops = new OpList(PlayerList.OPLIST_FILE);
+         this.whitelist = new WhiteList(PlayerList.WHITELIST_FILE);
+-        this.stats = Maps.newHashMap();
+-        this.advancements = Maps.newHashMap();
++        // CraftBukkit start
++        // this.stats = Maps.newHashMap();
++        // this.advancements = Maps.newHashMap();
++        // CraftBukkit end
+         this.server = minecraftserver;
+         this.registries = layeredregistryaccess;
+         this.maxPlayers = i;
+@@ -150,25 +183,34 @@
+     public void placeNewPlayer(NetworkManager networkmanager, EntityPlayer entityplayer, CommonListenerCookie commonlistenercookie) {
+         GameProfile gameprofile = entityplayer.getGameProfile();
+         UserCache usercache = this.server.getProfileCache();
+-        Optional optional;
++        // Optional optional; // CraftBukkit - decompile error
+         String s;
+ 
+         if (usercache != null) {
+-            optional = usercache.get(gameprofile.getId());
++            Optional<GameProfile> optional = usercache.get(gameprofile.getId()); // CraftBukkit - decompile error
+             s = (String) optional.map(GameProfile::getName).orElse(gameprofile.getName());
+             usercache.add(gameprofile);
+         } else {
+             s = gameprofile.getName();
+         }
+ 
+-        optional = this.load(entityplayer);
++        Optional<NBTTagCompound> optional = this.load(entityplayer); // CraftBukkit - decompile error
++        // CraftBukkit start - Better rename detection
++        if (optional.isPresent()) {
++            NBTTagCompound nbttagcompound = optional.get();
++            if (nbttagcompound.contains("bukkit")) {
++                NBTTagCompound bukkit = nbttagcompound.getCompound("bukkit");
++                s = bukkit.contains("lastKnownName", 8) ? bukkit.getString("lastKnownName") : s;
++            }
++        }
++        // CraftBukkit end
+         ResourceKey<World> resourcekey = (ResourceKey) optional.flatMap((nbttagcompound) -> {
+-            DataResult dataresult = DimensionManager.parseLegacy(new Dynamic(DynamicOpsNBT.INSTANCE, nbttagcompound.get("Dimension")));
++            DataResult<ResourceKey<World>> dataresult = DimensionManager.parseLegacy(new Dynamic(DynamicOpsNBT.INSTANCE, nbttagcompound.get("Dimension"))); // CraftBukkit - decompile error
+             Logger logger = PlayerList.LOGGER;
+ 
+             Objects.requireNonNull(logger);
+             return dataresult.resultOrPartial(logger::error);
+-        }).orElse(World.OVERWORLD);
++        }).orElse(entityplayer.serverLevel().dimension()); // CraftBukkit - SPIGOT-7507: If no dimension, fall back to existing dimension loaded from "WorldUUID", which in turn defaults to World.OVERWORLD
+         WorldServer worldserver = this.server.getLevel(resourcekey);
+         WorldServer worldserver1;
+ 
+@@ -182,10 +224,11 @@
+         entityplayer.setServerLevel(worldserver1);
+         String s1 = networkmanager.getLoggableAddress(this.server.logIPs());
+ 
+-        PlayerList.LOGGER.info("{}[{}] logged in with entity id {} at ({}, {}, {})", new Object[]{entityplayer.getName().getString(), s1, entityplayer.getId(), entityplayer.getX(), entityplayer.getY(), entityplayer.getZ()});
++        // CraftBukkit - Moved message to after join
++        // PlayerList.LOGGER.info("{}[{}] logged in with entity id {} at ({}, {}, {})", new Object[]{entityplayer.getName().getString(), s1, entityplayer.getId(), entityplayer.getX(), entityplayer.getY(), entityplayer.getZ()});
+         WorldData worlddata = worldserver1.getLevelData();
+ 
+-        entityplayer.loadGameTypes((NBTTagCompound) optional.orElse((Object) null));
++        entityplayer.loadGameTypes((NBTTagCompound) optional.orElse(null)); // CraftBukkit - decompile error
+         PlayerConnection playerconnection = new PlayerConnection(this.server, networkmanager, entityplayer, commonlistenercookie);
+ 
+         networkmanager.setupInboundProtocol(GameProtocols.SERVERBOUND_TEMPLATE.bind(RegistryFriendlyByteBuf.decorator(this.server.registryAccess())), playerconnection);
+@@ -195,6 +238,7 @@
+         boolean flag2 = gamerules.getBoolean(GameRules.RULE_LIMITED_CRAFTING);
+ 
+         playerconnection.send(new PacketPlayOutLogin(entityplayer.getId(), worlddata.isHardcore(), this.server.levelKeys(), this.getMaxPlayers(), this.viewDistance, this.simulationDistance, flag1, !flag, flag2, entityplayer.createCommonSpawnInfo(worldserver1), this.server.enforceSecureProfile()));
++        entityplayer.getBukkitEntity().sendSupportedChannels(); // CraftBukkit
+         playerconnection.send(new PacketPlayOutServerDifficulty(worlddata.getDifficulty(), worlddata.isDifficultyLocked()));
+         playerconnection.send(new PacketPlayOutAbilities(entityplayer.getAbilities()));
+         playerconnection.send(new PacketPlayOutHeldItemSlot(entityplayer.getInventory().selected));
+@@ -213,8 +257,10 @@
+         } else {
+             ichatmutablecomponent = IChatBaseComponent.translatable("multiplayer.player.joined.renamed", entityplayer.getDisplayName(), s);
+         }
++        // CraftBukkit start
++        ichatmutablecomponent.withStyle(EnumChatFormat.YELLOW);
++        String joinMessage = CraftChatMessage.fromComponent(ichatmutablecomponent);
+ 
+-        this.broadcastSystemMessage(ichatmutablecomponent.withStyle(EnumChatFormat.YELLOW), false);
+         playerconnection.teleport(entityplayer.getX(), entityplayer.getY(), entityplayer.getZ(), entityplayer.getYRot(), entityplayer.getXRot());
+         ServerPing serverping = this.server.getStatus();
+ 
+@@ -222,17 +268,70 @@
+             entityplayer.sendServerStatus(serverping);
+         }
+ 
+-        entityplayer.connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(this.players));
++        // entityplayer.connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(this.players)); // CraftBukkit - replaced with loop below
+         this.players.add(entityplayer);
+         this.playersByUUID.put(entityplayer.getUUID(), entityplayer);
+-        this.broadcastAll(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(List.of(entityplayer)));
++        // this.broadcastAll(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(List.of(entityplayer))); // CraftBukkit - replaced with loop below
++
++        // CraftBukkit start
++        CraftPlayer bukkitPlayer = entityplayer.getBukkitEntity();
++
++        // Ensure that player inventory is populated with its viewer
++        entityplayer.containerMenu.transferTo(entityplayer.containerMenu, bukkitPlayer);
++
++        PlayerJoinEvent playerJoinEvent = new PlayerJoinEvent(bukkitPlayer, joinMessage);
++        cserver.getPluginManager().callEvent(playerJoinEvent);
++
++        if (!entityplayer.connection.isAcceptingMessages()) {
++            return;
++        }
++
++        joinMessage = playerJoinEvent.getJoinMessage();
++
++        if (joinMessage != null && joinMessage.length() > 0) {
++            for (IChatBaseComponent line : org.bukkit.craftbukkit.util.CraftChatMessage.fromString(joinMessage)) {
++                server.getPlayerList().broadcastSystemMessage(line, false);
++            }
++        }
++        // CraftBukkit end
++
++        // CraftBukkit start - sendAll above replaced with this loop
++        ClientboundPlayerInfoUpdatePacket packet = ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(List.of(entityplayer));
++
++        for (int i = 0; i < this.players.size(); ++i) {
++            EntityPlayer entityplayer1 = (EntityPlayer) this.players.get(i);
++
++            if (entityplayer1.getBukkitEntity().canSee(bukkitPlayer)) {
++                entityplayer1.connection.send(packet);
++            }
++
++            if (!bukkitPlayer.canSee(entityplayer1.getBukkitEntity())) {
++                continue;
++            }
++
++            entityplayer.connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(List.of(entityplayer1)));
++        }
++        entityplayer.sentListPacket = true;
++        // CraftBukkit end
++
++        entityplayer.refreshEntityData(entityplayer); // CraftBukkit - BungeeCord#2321, send complete data to self on spawn
++
+         this.sendLevelInfo(entityplayer, worldserver1);
+-        worldserver1.addNewPlayer(entityplayer);
+-        this.server.getCustomBossEvents().onPlayerConnect(entityplayer);
++
++        // CraftBukkit start - Only add if the player wasn't moved in the event
++        if (entityplayer.level() == worldserver1 && !worldserver1.players().contains(entityplayer)) {
++            worldserver1.addNewPlayer(entityplayer);
++            this.server.getCustomBossEvents().onPlayerConnect(entityplayer);
++        }
++
++        worldserver1 = entityplayer.serverLevel(); // CraftBukkit - Update in case join event changed it
++        // CraftBukkit end
+         this.sendActivePlayerEffects(entityplayer);
+         entityplayer.loadAndSpawnEnderpearls(optional);
+         entityplayer.loadAndSpawnParentVehicle(optional);
+         entityplayer.initInventoryMenu();
++        // CraftBukkit - Moved from above, added world
++        PlayerList.LOGGER.info("{}[{}] logged in with entity id {} at ([{}]{}, {}, {})", entityplayer.getName().getString(), s1, entityplayer.getId(), worldserver1.serverLevelData.getLevelName(), entityplayer.getX(), entityplayer.getY(), entityplayer.getZ());
+     }
+ 
+     public void updateEntireScoreboard(ScoreboardServer scoreboardserver, EntityPlayer entityplayer) {
+@@ -269,30 +368,31 @@
+     }
+ 
+     public void addWorldborderListener(WorldServer worldserver) {
++        if (playerIo != null) return; // CraftBukkit
+         worldserver.getWorldBorder().addListener(new IWorldBorderListener() {
+             @Override
+             public void onBorderSizeSet(WorldBorder worldborder, double d0) {
+-                PlayerList.this.broadcastAll(new ClientboundSetBorderSizePacket(worldborder));
++                PlayerList.this.broadcastAll(new ClientboundSetBorderSizePacket(worldborder), worldborder.world); // CraftBukkit
+             }
+ 
+             @Override
+             public void onBorderSizeLerping(WorldBorder worldborder, double d0, double d1, long i) {
+-                PlayerList.this.broadcastAll(new ClientboundSetBorderLerpSizePacket(worldborder));
++                PlayerList.this.broadcastAll(new ClientboundSetBorderLerpSizePacket(worldborder), worldborder.world); // CraftBukkit
+             }
+ 
+             @Override
+             public void onBorderCenterSet(WorldBorder worldborder, double d0, double d1) {
+-                PlayerList.this.broadcastAll(new ClientboundSetBorderCenterPacket(worldborder));
++                PlayerList.this.broadcastAll(new ClientboundSetBorderCenterPacket(worldborder), worldborder.world); // CraftBukkit
+             }
+ 
+             @Override
+             public void onBorderSetWarningTime(WorldBorder worldborder, int i) {
+-                PlayerList.this.broadcastAll(new ClientboundSetBorderWarningDelayPacket(worldborder));
++                PlayerList.this.broadcastAll(new ClientboundSetBorderWarningDelayPacket(worldborder), worldborder.world); // CraftBukkit
+             }
+ 
+             @Override
+             public void onBorderSetWarningBlocks(WorldBorder worldborder, int i) {
+-                PlayerList.this.broadcastAll(new ClientboundSetBorderWarningDistancePacket(worldborder));
++                PlayerList.this.broadcastAll(new ClientboundSetBorderWarningDistancePacket(worldborder), worldborder.world); // CraftBukkit
+             }
+ 
+             @Override
+@@ -319,14 +419,15 @@
+     }
+ 
+     protected void save(EntityPlayer entityplayer) {
++        if (!entityplayer.getBukkitEntity().isPersistent()) return; // CraftBukkit
+         this.playerIo.save(entityplayer);
+-        ServerStatisticManager serverstatisticmanager = (ServerStatisticManager) this.stats.get(entityplayer.getUUID());
++        ServerStatisticManager serverstatisticmanager = (ServerStatisticManager) entityplayer.getStats(); // CraftBukkit
+ 
+         if (serverstatisticmanager != null) {
+             serverstatisticmanager.save();
+         }
+ 
+-        AdvancementDataPlayer advancementdataplayer = (AdvancementDataPlayer) this.advancements.get(entityplayer.getUUID());
++        AdvancementDataPlayer advancementdataplayer = (AdvancementDataPlayer) entityplayer.getAdvancements(); // CraftBukkit
+ 
+         if (advancementdataplayer != null) {
+             advancementdataplayer.save();
+@@ -334,10 +435,24 @@
+ 
+     }
+ 
+-    public void remove(EntityPlayer entityplayer) {
++    public String remove(EntityPlayer entityplayer) { // CraftBukkit - return string
+         WorldServer worldserver = entityplayer.serverLevel();
+ 
+         entityplayer.awardStat(StatisticList.LEAVE_GAME);
++
++        // CraftBukkit start - Quitting must be before we do final save of data, in case plugins need to modify it
++        // See SPIGOT-5799, SPIGOT-6145
++        if (entityplayer.containerMenu != entityplayer.inventoryMenu) {
++            entityplayer.closeContainer();
++        }
++
++        PlayerQuitEvent playerQuitEvent = new PlayerQuitEvent(entityplayer.getBukkitEntity(), entityplayer.kickLeaveMessage != null ? entityplayer.kickLeaveMessage : "\u00A7e" + entityplayer.getScoreboardName() + " left the game");
++        cserver.getPluginManager().callEvent(playerQuitEvent);
++        entityplayer.getBukkitEntity().disconnect(playerQuitEvent.getQuitMessage());
++
++        entityplayer.doTick(); // SPIGOT-924
++        // CraftBukkit end
++
+         this.save(entityplayer);
+         if (entityplayer.isPassenger()) {
+             Entity entity = entityplayer.getRootVehicle();
+@@ -346,7 +461,7 @@
+                 PlayerList.LOGGER.debug("Removing player mount");
+                 entityplayer.stopRiding();
+                 entity.getPassengersAndSelf().forEach((entity1) -> {
+-                    entity1.setRemoved(Entity.RemovalReason.UNLOADED_WITH_PLAYER);
++                    entity1.setRemoved(Entity.RemovalReason.UNLOADED_WITH_PLAYER, EntityRemoveEvent.Cause.PLAYER_QUIT); // CraftBukkit - add Bukkit remove cause
+                 });
+             }
+         }
+@@ -357,7 +472,7 @@
+         while (iterator.hasNext()) {
+             EntityEnderPearl entityenderpearl = (EntityEnderPearl) iterator.next();
+ 
+-            entityenderpearl.setRemoved(Entity.RemovalReason.UNLOADED_WITH_PLAYER);
++            entityenderpearl.setRemoved(Entity.RemovalReason.UNLOADED_WITH_PLAYER, EntityRemoveEvent.Cause.PLAYER_QUIT); // CraftBukkit - add Bukkit remove cause
+         }
+ 
+         worldserver.removePlayerImmediately(entityplayer, Entity.RemovalReason.UNLOADED_WITH_PLAYER);
+@@ -369,17 +484,66 @@
+ 
+         if (entityplayer1 == entityplayer) {
+             this.playersByUUID.remove(uuid);
+-            this.stats.remove(uuid);
+-            this.advancements.remove(uuid);
++            // CraftBukkit start
++            // this.stats.remove(uuid);
++            // this.advancements.remove(uuid);
++            // CraftBukkit end
+         }
+ 
+-        this.broadcastAll(new ClientboundPlayerInfoRemovePacket(List.of(entityplayer.getUUID())));
++        // CraftBukkit start
++        // this.broadcastAll(new ClientboundPlayerInfoRemovePacket(List.of(entityplayer.getUUID())));
++        ClientboundPlayerInfoRemovePacket packet = new ClientboundPlayerInfoRemovePacket(List.of(entityplayer.getUUID()));
++        for (int i = 0; i < players.size(); i++) {
++            EntityPlayer entityplayer2 = (EntityPlayer) this.players.get(i);
++
++            if (entityplayer2.getBukkitEntity().canSee(entityplayer.getBukkitEntity())) {
++                entityplayer2.connection.send(packet);
++            } else {
++                entityplayer2.getBukkitEntity().onEntityRemove(entityplayer);
++            }
++        }
++        // This removes the scoreboard (and player reference) for the specific player in the manager
++        cserver.getScoreboardManager().removePlayer(entityplayer.getBukkitEntity());
++        // CraftBukkit end
++
++        return playerQuitEvent.getQuitMessage(); // CraftBukkit
+     }
+ 
+-    @Nullable
+-    public IChatBaseComponent canPlayerLogin(SocketAddress socketaddress, GameProfile gameprofile) {
++    // CraftBukkit start - Whole method, SocketAddress to LoginListener, added hostname to signature, return EntityPlayer
++    public EntityPlayer canPlayerLogin(LoginListener loginlistener, GameProfile gameprofile) {
+         IChatMutableComponent ichatmutablecomponent;
+ 
++        // Moved from processLogin
++        UUID uuid = gameprofile.getId();
++        List<EntityPlayer> list = Lists.newArrayList();
++
++        EntityPlayer entityplayer;
++
++        for (int i = 0; i < this.players.size(); ++i) {
++            entityplayer = (EntityPlayer) this.players.get(i);
++            if (entityplayer.getUUID().equals(uuid)) {
++                list.add(entityplayer);
++            }
++        }
++
++        Iterator iterator = list.iterator();
++
++        while (iterator.hasNext()) {
++            entityplayer = (EntityPlayer) iterator.next();
++            save(entityplayer); // CraftBukkit - Force the player's inventory to be saved
++            entityplayer.connection.disconnect(IChatBaseComponent.translatable("multiplayer.disconnect.duplicate_login"));
++        }
++
++        // Instead of kicking then returning, we need to store the kick reason
++        // in the event, check with plugins to see if it's ok, and THEN kick
++        // depending on the outcome.
++        SocketAddress socketaddress = loginlistener.connection.getRemoteAddress();
++
++        EntityPlayer entity = new EntityPlayer(this.server, this.server.getLevel(World.OVERWORLD), gameprofile, ClientInformation.createDefault());
++        entity.transferCookieConnection = loginlistener;
++        Player player = entity.getBukkitEntity();
++        PlayerLoginEvent event = new PlayerLoginEvent(player, loginlistener.connection.hostname, ((java.net.InetSocketAddress) socketaddress).getAddress());
++
+         if (this.bans.isBanned(gameprofile)) {
+             GameProfileBanEntry gameprofilebanentry = (GameProfileBanEntry) this.bans.get(gameprofile);
+ 
+@@ -388,9 +552,11 @@
+                 ichatmutablecomponent.append((IChatBaseComponent) IChatBaseComponent.translatable("multiplayer.disconnect.banned.expiration", PlayerList.BAN_DATE_FORMAT.format(gameprofilebanentry.getExpires())));
+             }
+ 
+-            return ichatmutablecomponent;
++            // return chatmessage;
++            event.disallow(PlayerLoginEvent.Result.KICK_BANNED, CraftChatMessage.fromComponent(ichatmutablecomponent));
+         } else if (!this.isWhiteListed(gameprofile)) {
+-            return IChatBaseComponent.translatable("multiplayer.disconnect.not_whitelisted");
++            ichatmutablecomponent = IChatBaseComponent.translatable("multiplayer.disconnect.not_whitelisted");
++            event.disallow(PlayerLoginEvent.Result.KICK_WHITELIST, CraftChatMessage.fromComponent(ichatmutablecomponent));
+         } else if (this.ipBans.isBanned(socketaddress)) {
+             IpBanEntry ipbanentry = this.ipBans.get(socketaddress);
+ 
+@@ -399,17 +565,32 @@
+                 ichatmutablecomponent.append((IChatBaseComponent) IChatBaseComponent.translatable("multiplayer.disconnect.banned_ip.expiration", PlayerList.BAN_DATE_FORMAT.format(ipbanentry.getExpires())));
+             }
+ 
+-            return ichatmutablecomponent;
++            // return chatmessage;
++            event.disallow(PlayerLoginEvent.Result.KICK_BANNED, CraftChatMessage.fromComponent(ichatmutablecomponent));
+         } else {
+-            return this.players.size() >= this.maxPlayers && !this.canBypassPlayerLimit(gameprofile) ? IChatBaseComponent.translatable("multiplayer.disconnect.server_full") : null;
++            // return this.players.size() >= this.maxPlayers && !this.canBypassPlayerLimit(gameprofile) ? IChatBaseComponent.translatable("multiplayer.disconnect.server_full") : null;
++            if (this.players.size() >= this.maxPlayers && !this.canBypassPlayerLimit(gameprofile)) {
++                event.disallow(PlayerLoginEvent.Result.KICK_FULL, "The server is full");
++            }
++        }
++
++        cserver.getPluginManager().callEvent(event);
++        if (event.getResult() != PlayerLoginEvent.Result.ALLOWED) {
++            loginlistener.disconnect(event.getKickMessage());
++            return null;
+         }
++        return entity;
+     }
+ 
+-    public EntityPlayer getPlayerForLogin(GameProfile gameprofile, ClientInformation clientinformation) {
+-        return new EntityPlayer(this.server, this.server.overworld(), gameprofile, clientinformation);
++    // CraftBukkit start - added EntityPlayer
++    public EntityPlayer getPlayerForLogin(GameProfile gameprofile, ClientInformation clientinformation, EntityPlayer player) {
++        player.updateOptions(clientinformation);
++        return player;
++        // CraftBukkit end
+     }
+ 
+-    public boolean disconnectAllPlayersWithProfile(GameProfile gameprofile) {
++    public boolean disconnectAllPlayersWithProfile(GameProfile gameprofile, EntityPlayer player) { // CraftBukkit - added EntityPlayer
++        /* CraftBukkit startMoved up
+         UUID uuid = gameprofile.getId();
+         Set<EntityPlayer> set = Sets.newIdentityHashSet();
+         Iterator iterator = this.players.iterator();
+@@ -437,22 +618,41 @@
+         }
+ 
+         return !set.isEmpty();
++        */
++        return player == null;
++        // CraftBukkit end
+     }
+ 
+-    public EntityPlayer respawn(EntityPlayer entityplayer, boolean flag, Entity.RemovalReason entity_removalreason) {
++    // CraftBukkit start
++    public EntityPlayer respawn(EntityPlayer entityplayer, boolean flag, Entity.RemovalReason entity_removalreason, RespawnReason reason) {
++        return this.respawn(entityplayer, flag, entity_removalreason, reason, null);
++    }
++
++    public EntityPlayer respawn(EntityPlayer entityplayer, boolean flag, Entity.RemovalReason entity_removalreason, RespawnReason reason, Location location) {
++        entityplayer.stopRiding(); // CraftBukkit
+         this.players.remove(entityplayer);
+         entityplayer.serverLevel().removePlayerImmediately(entityplayer, entity_removalreason);
++        /* CraftBukkit start
+         TeleportTransition teleporttransition = entityplayer.findRespawnPositionAndUseSpawnBlock(!flag, TeleportTransition.DO_NOTHING);
+         WorldServer worldserver = teleporttransition.newLevel();
+         EntityPlayer entityplayer1 = new EntityPlayer(this.server, worldserver, entityplayer.getGameProfile(), entityplayer.clientInformation());
++        // */
++        EntityPlayer entityplayer1 = entityplayer;
++        World fromWorld = entityplayer.level();
++        entityplayer.wonGame = false;
++        // CraftBukkit end
+ 
+         entityplayer1.connection = entityplayer.connection;
+         entityplayer1.restoreFrom(entityplayer, flag);
+         entityplayer1.setId(entityplayer.getId());
+         entityplayer1.setMainArm(entityplayer.getMainArm());
++        // CraftBukkit - not required, just copies old location into reused entity
++        /*
+         if (!teleporttransition.missingRespawnBlock()) {
+             entityplayer1.copyRespawnPosition(entityplayer);
+         }
++         */
++        // CraftBukkit end
+ 
+         Iterator iterator = entityplayer.getTags().iterator();
+ 
+@@ -462,11 +662,26 @@
+             entityplayer1.addTag(s);
+         }
+ 
++        // CraftBukkit start - fire PlayerRespawnEvent
++        TeleportTransition teleporttransition;
++        if (location == null) {
++            teleporttransition = entityplayer.findRespawnPositionAndUseSpawnBlock(!flag, TeleportTransition.DO_NOTHING, reason);
++
++            if (!flag) entityplayer.reset(); // SPIGOT-4785
++        } else {
++            teleporttransition = new TeleportTransition(((CraftWorld) location.getWorld()).getHandle(), CraftLocation.toVec3D(location), Vec3D.ZERO, location.getYaw(), location.getPitch(), TeleportTransition.DO_NOTHING);
++        }
++        WorldServer worldserver = teleporttransition.newLevel();
++        entityplayer1.spawnIn(worldserver);
++        entityplayer1.unsetRemoved();
++        entityplayer1.setShiftKeyDown(false);
+         Vec3D vec3d = teleporttransition.position();
+ 
+-        entityplayer1.moveTo(vec3d.x, vec3d.y, vec3d.z, teleporttransition.yRot(), teleporttransition.xRot());
++        entityplayer1.forceSetPositionRotation(vec3d.x, vec3d.y, vec3d.z, teleporttransition.yRot(), teleporttransition.xRot());
++        // CraftBukkit end
+         if (teleporttransition.missingRespawnBlock()) {
+             entityplayer1.connection.send(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.NO_RESPAWN_BLOCK_AVAILABLE, 0.0F));
++            entityplayer1.setRespawnPosition(null, null, 0f, false, false, PlayerSpawnChangeEvent.Cause.RESET); // CraftBukkit - SPIGOT-5988: Clear respawn location when obstructed
+         }
+ 
+         int i = flag ? 1 : 0;
+@@ -474,17 +689,19 @@
+         WorldData worlddata = worldserver1.getLevelData();
+ 
+         entityplayer1.connection.send(new PacketPlayOutRespawn(entityplayer1.createCommonSpawnInfo(worldserver1), (byte) i));
+-        entityplayer1.connection.teleport(entityplayer1.getX(), entityplayer1.getY(), entityplayer1.getZ(), entityplayer1.getYRot(), entityplayer1.getXRot());
++        entityplayer1.connection.teleport(CraftLocation.toBukkit(entityplayer1.position(), worldserver1.getWorld(), entityplayer1.getYRot(), entityplayer1.getXRot())); // CraftBukkit
+         entityplayer1.connection.send(new PacketPlayOutSpawnPosition(worldserver.getSharedSpawnPos(), worldserver.getSharedSpawnAngle()));
+         entityplayer1.connection.send(new PacketPlayOutServerDifficulty(worlddata.getDifficulty(), worlddata.isDifficultyLocked()));
+         entityplayer1.connection.send(new PacketPlayOutExperience(entityplayer1.experienceProgress, entityplayer1.totalExperience, entityplayer1.experienceLevel));
+         this.sendActivePlayerEffects(entityplayer1);
+         this.sendLevelInfo(entityplayer1, worldserver);
+         this.sendPlayerPermissionLevel(entityplayer1);
+-        worldserver.addRespawnedPlayer(entityplayer1);
+-        this.players.add(entityplayer1);
+-        this.playersByUUID.put(entityplayer1.getUUID(), entityplayer1);
+-        entityplayer1.initInventoryMenu();
++        if (!entityplayer.connection.isDisconnected()) {
++            worldserver.addRespawnedPlayer(entityplayer1);
++            this.players.add(entityplayer1);
++            this.playersByUUID.put(entityplayer1.getUUID(), entityplayer1);
++        }
++        // entityplayer1.initInventoryMenu();
+         entityplayer1.setHealth(entityplayer1.getHealth());
+         BlockPosition blockposition = entityplayer1.getRespawnPosition();
+         WorldServer worldserver2 = this.server.getLevel(entityplayer1.getRespawnDimension());
+@@ -496,6 +713,27 @@
+                 entityplayer1.connection.send(new PacketPlayOutNamedSoundEffect(SoundEffects.RESPAWN_ANCHOR_DEPLETE, SoundCategory.BLOCKS, (double) blockposition.getX(), (double) blockposition.getY(), (double) blockposition.getZ(), 1.0F, 1.0F, worldserver.getRandom().nextLong()));
+             }
+         }
++        // Added from changeDimension
++        sendAllPlayerInfo(entityplayer); // Update health, etc...
++        entityplayer.onUpdateAbilities();
++        for (MobEffect mobEffect : entityplayer.getActiveEffects()) {
++            entityplayer.connection.send(new PacketPlayOutEntityEffect(entityplayer.getId(), mobEffect, false)); // blend = false
++        }
++
++        // Fire advancement trigger
++        entityplayer.triggerDimensionChangeTriggers(worldserver);
++
++        // Don't fire on respawn
++        if (fromWorld != worldserver) {
++            PlayerChangedWorldEvent event = new PlayerChangedWorldEvent(entityplayer.getBukkitEntity(), fromWorld.getWorld());
++            server.server.getPluginManager().callEvent(event);
++        }
++
++        // Save player file again if they were disconnected
++        if (entityplayer.connection.isDisconnected()) {
++            this.save(entityplayer);
++        }
++        // CraftBukkit end
+ 
+         return entityplayer1;
+     }
+@@ -524,7 +762,18 @@
+ 
+     public void tick() {
+         if (++this.sendAllPlayerInfoIn > 600) {
+-            this.broadcastAll(new ClientboundPlayerInfoUpdatePacket(EnumSet.of(ClientboundPlayerInfoUpdatePacket.a.UPDATE_LATENCY), this.players));
++            // CraftBukkit start
++            for (int i = 0; i < this.players.size(); ++i) {
++                final EntityPlayer target = (EntityPlayer) this.players.get(i);
++
++                target.connection.send(new ClientboundPlayerInfoUpdatePacket(EnumSet.of(ClientboundPlayerInfoUpdatePacket.a.UPDATE_LATENCY), this.players.stream().filter(new Predicate<EntityPlayer>() {
++                    @Override
++                    public boolean test(EntityPlayer input) {
++                        return target.getBukkitEntity().canSee(input.getBukkitEntity());
++                    }
++                }).collect(Collectors.toList())));
++            }
++            // CraftBukkit end
+             this.sendAllPlayerInfoIn = 0;
+         }
+ 
+@@ -541,6 +790,25 @@
+ 
+     }
+ 
++    // CraftBukkit start - add a world/entity limited version
++    public void broadcastAll(Packet packet, EntityHuman entityhuman) {
++        for (int i = 0; i < this.players.size(); ++i) {
++            EntityPlayer entityplayer =  this.players.get(i);
++            if (entityhuman != null && !entityplayer.getBukkitEntity().canSee(entityhuman.getBukkitEntity())) {
++                continue;
++            }
++            ((EntityPlayer) this.players.get(i)).connection.send(packet);
++        }
++    }
++
++    public void broadcastAll(Packet packet, World world) {
++        for (int i = 0; i < world.players().size(); ++i) {
++            ((EntityPlayer) world.players().get(i)).connection.send(packet);
++        }
++
++    }
++    // CraftBukkit end
++
+     public void broadcastAll(Packet<?> packet, ResourceKey<World> resourcekey) {
+         Iterator iterator = this.players.iterator();
+ 
+@@ -619,7 +887,7 @@
+     }
+ 
+     public void deop(GameProfile gameprofile) {
+-        this.ops.remove((Object) gameprofile);
++        this.ops.remove(gameprofile); // CraftBukkit - decompile error
+         EntityPlayer entityplayer = this.getPlayer(gameprofile.getId());
+ 
+         if (entityplayer != null) {
+@@ -643,6 +911,7 @@
+             entityplayer.connection.send(new PacketPlayOutEntityStatus(entityplayer, b0));
+         }
+ 
++        entityplayer.getBukkitEntity().recalculatePermissions(); // CraftBukkit
+         this.server.getCommands().sendCommands(entityplayer);
+     }
+ 
+@@ -673,6 +942,12 @@
+         for (int i = 0; i < this.players.size(); ++i) {
+             EntityPlayer entityplayer = (EntityPlayer) this.players.get(i);
+ 
++            // CraftBukkit start - Test if player receiving packet can see the source of the packet
++            if (entityhuman != null && !entityplayer.getBukkitEntity().canSee(entityhuman.getBukkitEntity())) {
++               continue;
++            }
++            // CraftBukkit end
++
+             if (entityplayer != entityhuman && entityplayer.level().dimension() == resourcekey) {
+                 double d4 = d0 - entityplayer.getX();
+                 double d5 = d1 - entityplayer.getY();
+@@ -712,15 +987,19 @@
+     public void reloadWhiteList() {}
+ 
+     public void sendLevelInfo(EntityPlayer entityplayer, WorldServer worldserver) {
+-        WorldBorder worldborder = this.server.overworld().getWorldBorder();
++        WorldBorder worldborder = entityplayer.level().getWorldBorder(); // CraftBukkit
+ 
+         entityplayer.connection.send(new ClientboundInitializeBorderPacket(worldborder));
+         entityplayer.connection.send(new PacketPlayOutUpdateTime(worldserver.getGameTime(), worldserver.getDayTime(), worldserver.getGameRules().getBoolean(GameRules.RULE_DAYLIGHT)));
+         entityplayer.connection.send(new PacketPlayOutSpawnPosition(worldserver.getSharedSpawnPos(), worldserver.getSharedSpawnAngle()));
+         if (worldserver.isRaining()) {
+-            entityplayer.connection.send(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.START_RAINING, 0.0F));
+-            entityplayer.connection.send(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.RAIN_LEVEL_CHANGE, worldserver.getRainLevel(1.0F)));
+-            entityplayer.connection.send(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.THUNDER_LEVEL_CHANGE, worldserver.getThunderLevel(1.0F)));
++            // CraftBukkit start - handle player weather
++            // entityplayer.connection.send(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.START_RAINING, 0.0F));
++            // entityplayer.connection.send(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.RAIN_LEVEL_CHANGE, worldserver.getRainLevel(1.0F)));
++            // entityplayer.connection.send(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.THUNDER_LEVEL_CHANGE, worldserver.getThunderLevel(1.0F)));
++            entityplayer.setPlayerWeather(org.bukkit.WeatherType.DOWNFALL, false);
++            entityplayer.updateWeather(-worldserver.rainLevel, worldserver.rainLevel, -worldserver.thunderLevel, worldserver.thunderLevel);
++            // CraftBukkit end
+         }
+ 
+         entityplayer.connection.send(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.LEVEL_CHUNKS_LOAD_START, 0.0F));
+@@ -729,8 +1008,16 @@
+ 
+     public void sendAllPlayerInfo(EntityPlayer entityplayer) {
+         entityplayer.inventoryMenu.sendAllDataToRemote();
+-        entityplayer.resetSentInfo();
++        // entityplayer.resetSentInfo();
++        entityplayer.getBukkitEntity().updateScaledHealth(); // CraftBukkit - Update scaled health on respawn and worldchange
++        entityplayer.refreshEntityData(entityplayer); // CraftBukkkit - SPIGOT-7218: sync metadata
+         entityplayer.connection.send(new PacketPlayOutHeldItemSlot(entityplayer.getInventory().selected));
++        // CraftBukkit start - from GameRules
++        int i = entityplayer.serverLevel().getGameRules().getBoolean(GameRules.RULE_REDUCEDDEBUGINFO) ? 22 : 23;
++        entityplayer.connection.send(new PacketPlayOutEntityStatus(entityplayer, (byte) i));
++        float immediateRespawn = entityplayer.serverLevel().getGameRules().getBoolean(GameRules.RULE_DO_IMMEDIATE_RESPAWN) ? 1.0F: 0.0F;
++        entityplayer.connection.send(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.IMMEDIATE_RESPAWN, immediateRespawn));
++        // CraftBukkit end
+     }
+ 
+     public int getPlayerCount() {
+@@ -786,12 +1073,22 @@
+     }
+ 
+     public void removeAll() {
+-        for (int i = 0; i < this.players.size(); ++i) {
+-            ((EntityPlayer) this.players.get(i)).connection.disconnect((IChatBaseComponent) IChatBaseComponent.translatable("multiplayer.disconnect.server_shutdown"));
++        // CraftBukkit start - disconnect safely
++        for (EntityPlayer player : this.players) {
++            player.connection.disconnect(CraftChatMessage.fromStringOrEmpty(this.server.server.getShutdownMessage())); // CraftBukkit - add custom shutdown message
+         }
++        // CraftBukkit end
+ 
+     }
+ 
++    // CraftBukkit start
++    public void broadcastMessage(IChatBaseComponent[] iChatBaseComponents) {
++        for (IChatBaseComponent component : iChatBaseComponents) {
++            broadcastSystemMessage(component, false);
++        }
++    }
++    // CraftBukkit end
++
+     public void broadcastSystemMessage(IChatBaseComponent ichatbasecomponent, boolean flag) {
+         this.broadcastSystemMessage(ichatbasecomponent, (entityplayer) -> {
+             return ichatbasecomponent;
+@@ -849,16 +1146,23 @@
+         return playerchatmessage.hasSignature() && !playerchatmessage.hasExpiredServer(Instant.now());
+     }
+ 
+-    public ServerStatisticManager getPlayerStats(EntityHuman entityhuman) {
+-        UUID uuid = entityhuman.getUUID();
+-        ServerStatisticManager serverstatisticmanager = (ServerStatisticManager) this.stats.get(uuid);
++    // CraftBukkit start
++    public ServerStatisticManager getPlayerStats(EntityPlayer entityhuman) {
++        ServerStatisticManager serverstatisticmanager = entityhuman.getStats();
++        return serverstatisticmanager == null ? getPlayerStats(entityhuman.getUUID(), entityhuman.getDisplayName().getString()) : serverstatisticmanager;
++    }
++
++    public ServerStatisticManager getPlayerStats(UUID uuid, String displayName) {
++        EntityPlayer entityhuman = this.getPlayer(uuid);
++        ServerStatisticManager serverstatisticmanager = entityhuman == null ? null : (ServerStatisticManager) entityhuman.getStats();
++        // CraftBukkit end
+ 
+         if (serverstatisticmanager == null) {
+             File file = this.server.getWorldPath(SavedFile.PLAYER_STATS_DIR).toFile();
+             File file1 = new File(file, String.valueOf(uuid) + ".json");
+ 
+             if (!file1.exists()) {
+-                File file2 = new File(file, entityhuman.getName().getString() + ".json");
++                File file2 = new File(file, displayName + ".json"); // CraftBukkit
+                 Path path = file2.toPath();
+ 
+                 if (FileUtils.isPathNormalized(path) && FileUtils.isPathPortable(path) && path.startsWith(file.getPath()) && file2.isFile()) {
+@@ -867,7 +1171,7 @@
+             }
+ 
+             serverstatisticmanager = new ServerStatisticManager(this.server, file1);
+-            this.stats.put(uuid, serverstatisticmanager);
++            // this.stats.put(uuid, serverstatisticmanager); // CraftBukkit
+         }
+ 
+         return serverstatisticmanager;
+@@ -875,13 +1179,13 @@
+ 
+     public AdvancementDataPlayer getPlayerAdvancements(EntityPlayer entityplayer) {
+         UUID uuid = entityplayer.getUUID();
+-        AdvancementDataPlayer advancementdataplayer = (AdvancementDataPlayer) this.advancements.get(uuid);
++        AdvancementDataPlayer advancementdataplayer = (AdvancementDataPlayer) entityplayer.getAdvancements(); // CraftBukkit
+ 
+         if (advancementdataplayer == null) {
+             Path path = this.server.getWorldPath(SavedFile.PLAYER_ADVANCEMENTS_DIR).resolve(String.valueOf(uuid) + ".json");
+ 
+             advancementdataplayer = new AdvancementDataPlayer(this.server.getFixerUpper(), this, this.server.getAdvancements(), path, entityplayer);
+-            this.advancements.put(uuid, advancementdataplayer);
++            // this.advancements.put(uuid, advancementdataplayer); // CraftBukkit
+         }
+ 
+         advancementdataplayer.setPlayer(entityplayer);
+@@ -932,15 +1236,28 @@
+     }
+ 
+     public void reloadResources() {
+-        Iterator iterator = this.advancements.values().iterator();
++        // CraftBukkit start
++        /*Iterator iterator = this.advancements.values().iterator();
+ 
+         while (iterator.hasNext()) {
+             AdvancementDataPlayer advancementdataplayer = (AdvancementDataPlayer) iterator.next();
+ 
+             advancementdataplayer.reload(this.server.getAdvancements());
++        }*/
++
++        for (EntityPlayer player : players) {
++            player.getAdvancements().reload(this.server.getAdvancements());
++            player.getAdvancements().flushDirty(player); // CraftBukkit - trigger immediate flush of advancements
+         }
++        // CraftBukkit end
+ 
+         this.broadcastAll(new ClientboundUpdateTagsPacket(TagNetworkSerialization.serializeTagsToNetwork(this.registries)));
++        // CraftBukkit start
++        reloadRecipes();
++    }
++
++    public void reloadRecipes() {
++        // CraftBukkit end
+         CraftingManager craftingmanager = this.server.getRecipeManager();
+         PacketPlayOutRecipeUpdate packetplayoutrecipeupdate = new PacketPlayOutRecipeUpdate(craftingmanager.getSynchronizedItemProperties(), craftingmanager.getSynchronizedStonecutterRecipes());
+         Iterator iterator1 = this.players.iterator();

paper-server/patches/sources/net/minecraft/server/players/SleepStatus.patch

@@ -0,0 +1,44 @@
+--- a/net/minecraft/server/players/SleepStatus.java
++++ b/net/minecraft/server/players/SleepStatus.java
+@@ -18,9 +18,12 @@
+     }
+ 
+     public boolean areEnoughDeepSleeping(int i, List<EntityPlayer> list) {
+-        int j = (int) list.stream().filter(EntityHuman::isSleepingLongEnough).count();
++        // CraftBukkit start
++        int j = (int) list.stream().filter((eh) -> { return eh.isSleepingLongEnough() || eh.fauxSleeping; }).count();
++        boolean anyDeepSleep = list.stream().anyMatch(EntityHuman::isSleepingLongEnough);
+ 
+-        return j >= this.sleepersNeeded(i);
++        return anyDeepSleep && j >= this.sleepersNeeded(i);
++        // CraftBukkit end
+     }
+ 
+     public int sleepersNeeded(int i) {
+@@ -42,18 +45,24 @@
+         this.activePlayers = 0;
+         this.sleepingPlayers = 0;
+         Iterator iterator = list.iterator();
++        boolean anySleep = false; // CraftBukkit
+ 
+         while (iterator.hasNext()) {
+             EntityPlayer entityplayer = (EntityPlayer) iterator.next();
+ 
+             if (!entityplayer.isSpectator()) {
+                 ++this.activePlayers;
+-                if (entityplayer.isSleeping()) {
++                if (entityplayer.isSleeping() || entityplayer.fauxSleeping) { // CraftBukkit
+                     ++this.sleepingPlayers;
+                 }
++                // CraftBukkit start
++                if (entityplayer.isSleeping()) {
++                    anySleep = true;
++                }
++                // CraftBukkit end
+             }
+         }
+ 
+-        return (j > 0 || this.sleepingPlayers > 0) && (i != this.activePlayers || j != this.sleepingPlayers);
++        return anySleep && (j > 0 || this.sleepingPlayers > 0) && (i != this.activePlayers || j != this.sleepingPlayers); // CraftBukkit
+     }
+ }

paper-server/patches/sources/net/minecraft/server/players/UserCache.patch

@@ -0,0 +1,38 @@
+--- a/net/minecraft/server/players/UserCache.java
++++ b/net/minecraft/server/players/UserCache.java
+@@ -85,7 +85,7 @@
+                 }
+ 
+                 public void onProfileLookupFailed(String s1, Exception exception) {
+-                    atomicreference.set((Object) null);
++                    atomicreference.set(null); // CraftBukkit - decompile error
+                 }
+             };
+ 
+@@ -142,7 +142,7 @@
+             usercache_usercacheentry.setLastAccess(this.getNextOperation());
+             optional = Optional.of(usercache_usercacheentry.getProfile());
+         } else {
+-            optional = lookupGameProfile(this.profileRepository, s1);
++            optional = lookupGameProfile(this.profileRepository, s); // CraftBukkit - use correct case for offline players
+             if (optional.isPresent()) {
+                 this.add((GameProfile) optional.get());
+                 flag = false;
+@@ -208,7 +208,7 @@
+ 
+             label54:
+             {
+-                ArrayList arraylist;
++                List<UserCache.UserCacheEntry> arraylist; // CraftBukkit - decompile error
+ 
+                 try {
+                     JsonArray jsonarray = (JsonArray) this.gson.fromJson(bufferedreader, JsonArray.class);
+@@ -217,7 +217,7 @@
+                         DateFormat dateformat = createDateFormat();
+ 
+                         jsonarray.forEach((jsonelement) -> {
+-                            Optional optional = readGameProfile(jsonelement, dateformat);
++                            Optional<UserCache.UserCacheEntry> optional = readGameProfile(jsonelement, dateformat); // CraftBukkit - decompile error
+ 
+                             Objects.requireNonNull(list);
+                             optional.ifPresent(list::add);

paper-server/patches/sources/net/minecraft/server/rcon/RemoteControlCommandListener.patch

@@ -0,0 +1,45 @@
+--- a/net/minecraft/server/rcon/RemoteControlCommandListener.java
++++ b/net/minecraft/server/rcon/RemoteControlCommandListener.java
+@@ -9,14 +9,23 @@
+ import net.minecraft.world.phys.Vec2F;
+ import net.minecraft.world.phys.Vec3D;
+ 
++// CraftBukkit start
++import java.net.SocketAddress;
++import org.bukkit.craftbukkit.command.CraftRemoteConsoleCommandSender;
++// CraftBukkit end
+ public class RemoteControlCommandListener implements ICommandListener {
+ 
+     private static final String RCON = "Rcon";
+     private static final IChatBaseComponent RCON_COMPONENT = IChatBaseComponent.literal("Rcon");
+     private final StringBuffer buffer = new StringBuffer();
+     private final MinecraftServer server;
++    // CraftBukkit start
++    public final SocketAddress socketAddress;
++    private final CraftRemoteConsoleCommandSender remoteConsole = new CraftRemoteConsoleCommandSender(this);
+ 
+-    public RemoteControlCommandListener(MinecraftServer minecraftserver) {
++    public RemoteControlCommandListener(MinecraftServer minecraftserver, SocketAddress socketAddress) {
++        this.socketAddress = socketAddress;
++        // CraftBukkit end
+         this.server = minecraftserver;
+     }
+ 
+@@ -34,6 +43,17 @@
+         return new CommandListenerWrapper(this, Vec3D.atLowerCornerOf(worldserver.getSharedSpawnPos()), Vec2F.ZERO, worldserver, 4, "Rcon", RemoteControlCommandListener.RCON_COMPONENT, this.server, (Entity) null);
+     }
+ 
++    // CraftBukkit start - Send a String
++    public void sendMessage(String message) {
++        this.buffer.append(message);
++    }
++
++    @Override
++    public org.bukkit.command.CommandSender getBukkitSender(CommandListenerWrapper wrapper) {
++        return this.remoteConsole;
++    }
++    // CraftBukkit end
++
+     @Override
+     public void sendSystemMessage(IChatBaseComponent ichatbasecomponent) {
+         this.buffer.append(ichatbasecomponent.getString());

paper-server/patches/sources/net/minecraft/server/rcon/thread/RemoteControlSession.patch

@@ -0,0 +1,77 @@
+--- a/net/minecraft/server/rcon/thread/RemoteControlSession.java
++++ b/net/minecraft/server/rcon/thread/RemoteControlSession.java
+@@ -11,6 +11,10 @@
+ import net.minecraft.server.IMinecraftServer;
+ import net.minecraft.server.rcon.StatusChallengeUtils;
+ import org.slf4j.Logger;
++// CraftBukkit start
++import net.minecraft.server.dedicated.DedicatedServer;
++import net.minecraft.server.rcon.RemoteControlCommandListener;
++// CraftBukkit end
+ 
+ public class RemoteControlSession extends RemoteConnectionThread {
+ 
+@@ -24,11 +28,14 @@
+     private final Socket client;
+     private final byte[] buf = new byte[1460];
+     private final String rconPassword;
+-    private final IMinecraftServer serverInterface;
++    // CraftBukkit start
++    private final DedicatedServer serverInterface;
++    private final RemoteControlCommandListener rconConsoleSource;
++    // CraftBukkit end
+ 
+     RemoteControlSession(IMinecraftServer iminecraftserver, String s, Socket socket) {
+         super("RCON Client " + String.valueOf(socket.getInetAddress()));
+-        this.serverInterface = iminecraftserver;
++        this.serverInterface = (DedicatedServer) iminecraftserver; // CraftBukkit
+         this.client = socket;
+ 
+         try {
+@@ -38,11 +45,14 @@
+         }
+ 
+         this.rconPassword = s;
++        this.rconConsoleSource = new net.minecraft.server.rcon.RemoteControlCommandListener(this.serverInterface, socket.getRemoteSocketAddress()); // CraftBukkit
+     }
+ 
+     public void run() {
+-        while (true) {
+-            try {
++        // CraftBukkit start - decompile error: switch try / while statement
++        try {
++            while (true) {
++                // CraftBukkit end
+                 if (!this.running) {
+                     return;
+                 }
+@@ -71,7 +81,7 @@
+                                 String s = StatusChallengeUtils.stringFromByteArray(this.buf, j, i);
+ 
+                                 try {
+-                                    this.sendCmdResponse(l, this.serverInterface.runCommand(s));
++                                    this.sendCmdResponse(l, this.serverInterface.runCommand(this.rconConsoleSource, s)); // CraftBukkit
+                                 } catch (Exception exception) {
+                                     this.sendCmdResponse(l, "Error executing: " + s + " (" + exception.getMessage() + ")");
+                                 }
+@@ -98,6 +108,7 @@
+                             continue;
+                     }
+                 }
++        } // CraftBukkit - decompile error: switch try / while statement
+             } catch (IOException ioexception) {
+                 return;
+             } catch (Exception exception1) {
+@@ -109,8 +120,10 @@
+                 this.running = false;
+             }
+ 
+-            return;
+-        }
++            // CraftBukkit start - decompile error: switch try / while statement
++            // return;
++        // }
++        // CraftBukkit end
+     }
+ 
+     private void send(int i, int j, String s) throws IOException {