add remapped patches as a testsoftspoon

1 files changed, 550 insertions, 0 deletions

diff --git a/patch-remap/mache-vineflower/net/minecraft/server/Main.java.patch b/patch-remap/mache-vineflower/net/minecraft/server/Main.java.patch
new file mode 100644
index 0000000000..3183d249fe
--- /dev/null
+++ b/patch-remap/mache-vineflower/net/minecraft/server/Main.java.patch
@@ -0,0 +1,550 @@
+--- a/net/minecraft/server/Main.java
++++ b/net/minecraft/server/Main.java
+@@ -14,20 +14,20 @@
+ import java.nio.file.Path;
+ import java.nio.file.Paths;
+ import java.util.Optional;
+-import java.util.concurrent.Executor;
+ import java.util.function.BooleanSupplier;
+ import javax.annotation.Nullable;
++import joptsimple.NonOptionArgumentSpec;
+ import joptsimple.OptionParser;
+ import joptsimple.OptionSet;
+ import joptsimple.OptionSpec;
+ import joptsimple.util.PathConverter;
++import joptsimple.util.PathProperties;
+ import net.minecraft.CrashReport;
+ import net.minecraft.DefaultUncaughtExceptionHandler;
+ import net.minecraft.SharedConstants;
+ import net.minecraft.Util;
+ import net.minecraft.commands.Commands;
+ import net.minecraft.core.Registry;
+-import net.minecraft.core.RegistryAccess;
+ import net.minecraft.core.registries.Registries;
+ import net.minecraft.nbt.NbtException;
+ import net.minecraft.nbt.ReportedNbtException;
+@@ -37,6 +37,7 @@
+ import net.minecraft.server.dedicated.DedicatedServerProperties;
+ import net.minecraft.server.dedicated.DedicatedServerSettings;
+ import net.minecraft.server.level.progress.LoggerChunkProgressListener;
++import net.minecraft.server.packs.PackType;
+ import net.minecraft.server.packs.repository.PackRepository;
+ import net.minecraft.server.packs.repository.ServerPacksSource;
+ import net.minecraft.util.Mth;
+@@ -53,49 +54,66 @@
+ import net.minecraft.world.level.levelgen.WorldOptions;
+ import net.minecraft.world.level.levelgen.presets.WorldPresets;
+ import net.minecraft.world.level.storage.LevelDataAndDimensions;
++import net.minecraft.world.level.storage.LevelResource;
+ import net.minecraft.world.level.storage.LevelStorageSource;
+ import net.minecraft.world.level.storage.LevelSummary;
+ import net.minecraft.world.level.storage.PrimaryLevelData;
+-import net.minecraft.world.level.storage.WorldData;
+ 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 org.bukkit.configuration.file.YamlConfiguration;
++// CraftBukkit end
++
+ public class Main {
++
+     private static final Logger LOGGER = LogUtils.getLogger();
+ 
++    public Main() {}
++
+     @DontObfuscate
+-    public static void main(String[] args) {
++    public static void main(final OptionSet optionset) { // CraftBukkit - replaces main(String[] astring)
+         SharedConstants.tryDetectVersion();
+-        OptionParser optionParser = new OptionParser();
+-        OptionSpec<Void> optionSpec = optionParser.accepts("nogui");
+-        OptionSpec<Void> optionSpec1 = optionParser.accepts("initSettings", "Initializes 'server.properties' and 'eula.txt', then quits");
+-        OptionSpec<Void> optionSpec2 = optionParser.accepts("demo");
+-        OptionSpec<Void> optionSpec3 = optionParser.accepts("bonusChest");
+-        OptionSpec<Void> optionSpec4 = optionParser.accepts("forceUpgrade");
+-        OptionSpec<Void> optionSpec5 = optionParser.accepts("eraseCache");
+-        OptionSpec<Void> optionSpec6 = optionParser.accepts("safeMode", "Loads level with vanilla datapack only");
+-        OptionSpec<Void> optionSpec7 = optionParser.accepts("help").forHelp();
+-        OptionSpec<String> optionSpec8 = optionParser.accepts("universe").withRequiredArg().defaultsTo(".");
+-        OptionSpec<String> optionSpec9 = optionParser.accepts("world").withRequiredArg();
+-        OptionSpec<Integer> optionSpec10 = optionParser.accepts("port").withRequiredArg().ofType(Integer.class).defaultsTo(-1);
+-        OptionSpec<String> optionSpec11 = optionParser.accepts("serverId").withRequiredArg();
+-        OptionSpec<Void> optionSpec12 = optionParser.accepts("jfrProfile");
+-        OptionSpec<Path> optionSpec13 = optionParser.accepts("pidFile").withRequiredArg().withValuesConvertedBy(new PathConverter());
+-        OptionSpec<String> optionSpec14 = optionParser.nonOptions();
++        /* 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");
++        OptionSpec<Void> optionspec2 = optionparser.accepts("demo");
++        OptionSpec<Void> optionspec3 = optionparser.accepts("bonusChest");
++        OptionSpec<Void> optionspec4 = optionparser.accepts("forceUpgrade");
++        OptionSpec<Void> optionspec5 = optionparser.accepts("eraseCache");
++        OptionSpec<Void> optionspec6 = optionparser.accepts("safeMode", "Loads level with vanilla datapack only");
++        OptionSpec<Void> optionspec7 = optionparser.accepts("help").forHelp();
++        OptionSpec<String> optionspec8 = optionparser.accepts("universe").withRequiredArg().defaultsTo(".", new String[0]);
++        OptionSpec<String> optionspec9 = optionparser.accepts("world").withRequiredArg();
++        OptionSpec<Integer> optionspec10 = optionparser.accepts("port").withRequiredArg().ofType(Integer.class).defaultsTo(-1, new Integer[0]);
++        OptionSpec<String> optionspec11 = optionparser.accepts("serverId").withRequiredArg();
++        OptionSpec<Void> optionspec12 = optionparser.accepts("jfrProfile");
++        OptionSpec<Path> optionspec13 = optionparser.accepts("pidFile").withRequiredArg().withValuesConvertedBy(new PathConverter(new PathProperties[0]));
++        NonOptionArgumentSpec nonoptionargumentspec = optionparser.nonOptions();
+ 
+         try {
+-            OptionSet optionSet = optionParser.parse(args);
+-            if (optionSet.has(optionSpec7)) {
+-                optionParser.printHelpOn(System.err);
++            OptionSet optionset = optionparser.parse(astring);
++
++            if (optionset.has(optionspec7)) {
++                optionparser.printHelpOn(System.err);
+                 return;
+             }
++            */ // CraftBukkit end
+ 
+-            Path path = optionSet.valueOf(optionSpec13);
++        try {
++
++            Path path = (Path) optionset.valueOf("pidFile"); // CraftBukkit
++
+             if (path != null) {
+                 writePidFile(path);
+             }
+ 
+             CrashReport.preload();
+-            if (optionSet.has(optionSpec12)) {
++            if (optionset.has("jfrProfile")) { // CraftBukkit
+                 JvmProfiler.INSTANCE.start(Environment.SERVER);
+             }
+ 
+@@ -103,238 +121,264 @@
+             Bootstrap.validate();
+             Util.startTimerHackThread();
+             Path path1 = Paths.get("server.properties");
+-            DedicatedServerSettings dedicatedServerSettings = new DedicatedServerSettings(path1);
+-            dedicatedServerSettings.forceSave();
++            DedicatedServerSettings dedicatedserversettings = new DedicatedServerSettings(optionset); // CraftBukkit - CLI argument support
++
++            dedicatedserversettings.forceSave();
+             Path path2 = Paths.get("eula.txt");
+             Eula eula = new Eula(path2);
+-            if (optionSet.has(optionSpec1)) {
+-                LOGGER.info("Initialized '{}' and '{}'", path1.toAbsolutePath(), path2.toAbsolutePath());
++
++            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;
+             }
+ 
+             if (!eula.hasAgreedToEULA()) {
+-                LOGGER.info("You need to agree to the EULA in order to run the server. Go to eula.txt for more info.");
++                Main.LOGGER.info("You need to agree to the EULA in order to run the server. Go to eula.txt for more info.");
+                 return;
+             }
+ 
+-            File file = new File(optionSet.valueOf(optionSpec8));
++            File file = (File) optionset.valueOf("universe"); // CraftBukkit
+             Services services = Services.create(new YggdrasilAuthenticationService(Proxy.NO_PROXY), file);
+-            String string = Optional.ofNullable(optionSet.valueOf(optionSpec9)).orElse(dedicatedServerSettings.getProperties().levelName);
+-            LevelStorageSource levelStorageSource = LevelStorageSource.createDefault(file.toPath());
+-            LevelStorageSource.LevelStorageAccess levelStorageAccess = levelStorageSource.validateAndCreateAccess(string);
+-            Dynamic<?> dataTag;
+-            if (levelStorageAccess.hasWorldData()) {
+-                LevelSummary summary;
++            // CraftBukkit start
++            String s = (String) Optional.ofNullable((String) optionset.valueOf("world")).orElse(dedicatedserversettings.getProperties().levelName);
++            LevelStorageSource convertable = LevelStorageSource.createDefault(file.toPath());
++            LevelStorageSource.LevelStorageAccess convertable_conversionsession = convertable.validateAndCreateAccess(s, LevelStem.OVERWORLD);
++            // CraftBukkit end
++            Dynamic dynamic;
++
++            if (convertable_conversionsession.hasWorldData()) {
++                LevelSummary worldinfo;
++
+                 try {
+-                    dataTag = levelStorageAccess.getDataTag();
+-                    summary = levelStorageAccess.getSummary(dataTag);
+-                } catch (NbtException | ReportedNbtException | IOException var39) {
+-                    LevelStorageSource.LevelDirectory levelDirectory = levelStorageAccess.getLevelDirectory();
+-                    LOGGER.warn("Failed to load world data from {}", levelDirectory.dataFile(), var39);
+-                    LOGGER.info("Attempting to use fallback");
++                    dynamic = convertable_conversionsession.getDataTag();
++                    worldinfo = convertable_conversionsession.getSummary(dynamic);
++                } catch (NbtException | ReportedNbtException | IOException ioexception) {
++                    LevelStorageSource.LevelDirectory convertable_b = convertable_conversionsession.getLevelDirectory();
+ 
++                    Main.LOGGER.warn("Failed to load world data from {}", convertable_b.dataFile(), ioexception);
++                    Main.LOGGER.info("Attempting to use fallback");
++
+                     try {
+-                        dataTag = levelStorageAccess.getDataTagFallback();
+-                        summary = levelStorageAccess.getSummary(dataTag);
+-                    } catch (NbtException | ReportedNbtException | IOException var38) {
+-                        LOGGER.error("Failed to load world data from {}", levelDirectory.oldDataFile(), var38);
+-                        LOGGER.error(
+-                            "Failed to load world data from {} and {}. World files may be corrupted. Shutting down.",
+-                            levelDirectory.dataFile(),
+-                            levelDirectory.oldDataFile()
+-                        );
++                        dynamic = convertable_conversionsession.getDataTagFallback();
++                        worldinfo = convertable_conversionsession.getSummary(dynamic);
++                    } catch (NbtException | ReportedNbtException | IOException ioexception1) {
++                        Main.LOGGER.error("Failed to load world data from {}", convertable_b.oldDataFile(), ioexception1);
++                        Main.LOGGER.error("Failed to load world data from {} and {}. World files may be corrupted. Shutting down.", convertable_b.dataFile(), convertable_b.oldDataFile());
+                         return;
+                     }
+ 
+-                    levelStorageAccess.restoreLevelDataFromOld();
++                    convertable_conversionsession.restoreLevelDataFromOld();
+                 }
+ 
+-                if (summary.requiresManualConversion()) {
+-                    LOGGER.info("This world must be opened in an older version (like 1.6.4) to be safely converted");
++                if (worldinfo.requiresManualConversion()) {
++                    Main.LOGGER.info("This world must be opened in an older version (like 1.6.4) to be safely converted");
+                     return;
+                 }
+ 
+-                if (!summary.isCompatible()) {
+-                    LOGGER.info("This world was created by an incompatible version.");
++                if (!worldinfo.isCompatible()) {
++                    Main.LOGGER.info("This world was created by an incompatible version.");
+                     return;
+                 }
+             } else {
+-                dataTag = null;
++                dynamic = null;
+             }
+ 
+-            Dynamic<?> dynamic = dataTag;
+-            boolean hasOptionSpec = optionSet.has(optionSpec6);
+-            if (hasOptionSpec) {
+-                LOGGER.warn("Safe mode active, only vanilla datapack will be loaded");
++            Dynamic<?> dynamic1 = dynamic;
++            boolean flag = optionset.has("safeMode"); // CraftBukkit
++
++            if (flag) {
++                Main.LOGGER.warn("Safe mode active, only vanilla datapack will be loaded");
+             }
+ 
+-            PackRepository packRepository = ServerPacksSource.createPackRepository(levelStorageAccess);
++            PackRepository resourcepackrepository = ServerPacksSource.createPackRepository(convertable_conversionsession);
++            // CraftBukkit start
++            File bukkitDataPackFolder = new File(convertable_conversionsession.getLevelPath(LevelResource.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(PackType.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;
++            WorldStem worldstem;
++
+             try {
+-                WorldLoader.InitConfig initConfig = loadOrCreateConfig(dedicatedServerSettings.getProperties(), dynamic, hasOptionSpec, packRepository);
+-                worldStem = Util.<WorldStem>blockUntilDone(
+-                        executor -> WorldLoader.load(
+-                                initConfig,
+-                                context -> {
+-                                    Registry<LevelStem> registry = context.datapackDimensions().registryOrThrow(Registries.LEVEL_STEM);
+-                                    if (dynamic != null) {
+-                                        LevelDataAndDimensions levelDataAndDimensions = LevelStorageSource.getLevelDataAndDimensions(
+-                                            dynamic, context.dataConfiguration(), registry, context.datapackWorldgen()
+-                                        );
+-                                        return new WorldLoader.DataLoadOutput<>(
+-                                            levelDataAndDimensions.worldData(), levelDataAndDimensions.dimensions().dimensionsRegistryAccess()
+-                                        );
+-                                    } else {
+-                                        LOGGER.info("No existing world data, creating new world");
+-                                        LevelSettings levelSettings;
+-                                        WorldOptions worldOptions;
+-                                        WorldDimensions worldDimensions;
+-                                        if (optionSet.has(optionSpec2)) {
+-                                            levelSettings = MinecraftServer.DEMO_SETTINGS;
+-                                            worldOptions = WorldOptions.DEMO_OPTIONS;
+-                                            worldDimensions = WorldPresets.createNormalWorldDimensions(context.datapackWorldgen());
+-                                        } else {
+-                                            DedicatedServerProperties properties = dedicatedServerSettings.getProperties();
+-                                            levelSettings = new LevelSettings(
+-                                                properties.levelName,
+-                                                properties.gamemode,
+-                                                properties.hardcore,
+-                                                properties.difficulty,
+-                                                false,
+-                                                new GameRules(),
+-                                                context.dataConfiguration()
+-                                            );
+-                                            worldOptions = optionSet.has(optionSpec3) ? properties.worldOptions.withBonusChest(true) : properties.worldOptions;
+-                                            worldDimensions = properties.createDimensions(context.datapackWorldgen());
+-                                        }
+-            
+-                                        WorldDimensions.Complete complete = worldDimensions.bake(registry);
+-                                        Lifecycle lifecycle = complete.lifecycle().add(context.datapackWorldgen().allRegistriesLifecycle());
+-                                        return new WorldLoader.DataLoadOutput<>(
+-                                            new PrimaryLevelData(levelSettings, worldOptions, complete.specialWorldProperty(), lifecycle),
+-                                            complete.dimensionsRegistryAccess()
+-                                        );
+-                                    }
+-                                },
+-                                WorldStem::new,
+-                                Util.backgroundExecutor(),
+-                                executor
+-                            )
+-                    )
+-                    .get();
+-            } catch (Exception var37) {
+-                LOGGER.warn(
+-                    "Failed to load datapacks, can't proceed with server load. You can either fix your datapacks or reset to vanilla with --safeMode",
+-                    (Throwable)var37
+-                );
++                WorldLoader.c worldloader_c = loadOrCreateConfig(dedicatedserversettings.getProperties(), dynamic1, flag, resourcepackrepository);
++
++                worldstem = (WorldStem) Util.blockUntilDone((executor) -> {
++                    return WorldLoader.load(worldloader_c, (worldloader_a) -> {
++                        worldLoader.set(worldloader_a); // CraftBukkit
++                        Registry<LevelStem> iregistry = worldloader_a.datapackDimensions().registryOrThrow(Registries.LEVEL_STEM);
++
++                        if (dynamic1 != null) {
++                            LevelDataAndDimensions leveldataanddimensions = LevelStorageSource.getLevelDataAndDimensions(dynamic1, worldloader_a.dataConfiguration(), iregistry, worldloader_a.datapackWorldgen());
++
++                            return new WorldLoader.b<>(leveldataanddimensions.worldData(), leveldataanddimensions.dimensions().dimensionsRegistryAccess());
++                        } else {
++                            Main.LOGGER.info("No existing world data, creating new world");
++                            LevelSettings worldsettings;
++                            WorldOptions worldoptions;
++                            WorldDimensions worlddimensions;
++
++                            if (optionset.has("demo")) { // CraftBukkit
++                                worldsettings = MinecraftServer.DEMO_SETTINGS;
++                                worldoptions = WorldOptions.DEMO_OPTIONS;
++                                worlddimensions = WorldPresets.createNormalWorldDimensions(worldloader_a.datapackWorldgen());
++                            } else {
++                                DedicatedServerProperties dedicatedserverproperties = dedicatedserversettings.getProperties();
++
++                                worldsettings = new LevelSettings(dedicatedserverproperties.levelName, dedicatedserverproperties.gamemode, dedicatedserverproperties.hardcore, dedicatedserverproperties.difficulty, false, new GameRules(), worldloader_a.dataConfiguration());
++                                worldoptions = optionset.has("bonusChest") ? dedicatedserverproperties.worldOptions.withBonusChest(true) : dedicatedserverproperties.worldOptions; // CraftBukkit
++                                worlddimensions = dedicatedserverproperties.createDimensions(worldloader_a.datapackWorldgen());
++                            }
++
++                            WorldDimensions.b worlddimensions_b = worlddimensions.bake(iregistry);
++                            Lifecycle lifecycle = worlddimensions_b.lifecycle().add(worldloader_a.datapackWorldgen().allRegistriesLifecycle());
++
++                            return new WorldLoader.b<>(new PrimaryLevelData(worldsettings, worldoptions, worlddimensions_b.specialWorldProperty(), lifecycle), worlddimensions_b.dimensionsRegistryAccess());
++                        }
++                    }, WorldStem::new, Util.backgroundExecutor(), executor);
++                }).get();
++            } catch (Exception exception) {
++                Main.LOGGER.warn("Failed to load datapacks, can't proceed with server load. You can either fix your datapacks or reset to vanilla with --safeMode", exception);
+                 return;
+             }
+ 
+-            RegistryAccess.Frozen frozen = worldStem.registries().compositeAccess();
+-            if (optionSet.has(optionSpec4)) {
+-                forceUpgrade(
+-                    levelStorageAccess, DataFixers.getDataFixer(), optionSet.has(optionSpec5), () -> true, frozen.registryOrThrow(Registries.LEVEL_STEM)
+-                );
++            /*
++            IRegistryCustom.Dimension iregistrycustom_dimension = worldstem.registries().compositeAccess();
++
++            if (optionset.has(optionspec4)) {
++                forceUpgrade(convertable_conversionsession, DataConverterRegistry.getDataFixer(), optionset.has(optionspec5), () -> {
++                    return true;
++                }, iregistrycustom_dimension.registryOrThrow(Registries.LEVEL_STEM));
+             }
+ 
+-            WorldData worldData = worldStem.worldData();
+-            levelStorageAccess.saveDataTag(frozen, worldData);
+-            final DedicatedServer dedicatedServer = MinecraftServer.spin(
+-                thread1 -> {
+-                    DedicatedServer dedicatedServer1 = new DedicatedServer(
+-                        thread1,
+-                        levelStorageAccess,
+-                        packRepository,
+-                        worldStem,
+-                        dedicatedServerSettings,
+-                        DataFixers.getDataFixer(),
+-                        services,
+-                        LoggerChunkProgressListener::new
+-                    );
+-                    dedicatedServer1.setPort(optionSet.valueOf(optionSpec10));
+-                    dedicatedServer1.setDemo(optionSet.has(optionSpec2));
+-                    dedicatedServer1.setId(optionSet.valueOf(optionSpec11));
+-                    boolean flag = !optionSet.has(optionSpec) && !optionSet.valuesOf(optionSpec14).contains("nogui");
+-                    if (flag && !GraphicsEnvironment.isHeadless()) {
+-                        dedicatedServer1.showGui();
++            SaveData savedata = worldstem.worldData();
++
++            convertable_conversionsession.saveDataTag(iregistrycustom_dimension, savedata);
++            */
++            final DedicatedServer dedicatedserver = (DedicatedServer) MinecraftServer.spin((thread) -> {
++                DedicatedServer dedicatedserver1 = new DedicatedServer(optionset, worldLoader.get(), thread, convertable_conversionsession, resourcepackrepository, worldstem, dedicatedserversettings, DataFixers.getDataFixer(), services, LoggerChunkProgressListener::new);
++
++                /*
++                dedicatedserver1.setPort((Integer) optionset.valueOf(optionspec10));
++                dedicatedserver1.setDemo(optionset.has(optionspec2));
++                dedicatedserver1.setId((String) optionset.valueOf(optionspec11));
++                */
++                boolean flag1 = !optionset.has("nogui") && !optionset.nonOptionArguments().contains("nogui");
++
++                if (flag1 && !GraphicsEnvironment.isHeadless()) {
++                    dedicatedserver1.showGui();
++                }
++
++                if (optionset.has("port")) {
++                    int port = (Integer) optionset.valueOf("port");
++                    if (port > 0) {
++                        dedicatedserver1.setPort(port);
+                     }
+-    
+-                    return dedicatedServer1;
+                 }
+-            );
++
++                return dedicatedserver1;
++            });
++            /* CraftBukkit start
+             Thread thread = new Thread("Server Shutdown Thread") {
+-                @Override
+                 public void run() {
+-                    dedicatedServer.halt(true);
++                    dedicatedserver.halt(true);
+                 }
+             };
+-            thread.setUncaughtExceptionHandler(new DefaultUncaughtExceptionHandler(LOGGER));
++
++            thread.setUncaughtExceptionHandler(new DefaultUncaughtExceptionHandler(Main.LOGGER));
+             Runtime.getRuntime().addShutdownHook(thread);
+-        } catch (Exception var40) {
+-            LOGGER.error(LogUtils.FATAL_MARKER, "Failed to start the minecraft server", (Throwable)var40);
++            */ // CraftBukkit end
++        } catch (Exception exception1) {
++            Main.LOGGER.error(LogUtils.FATAL_MARKER, "Failed to start the minecraft server", exception1);
+         }
++
+     }
+ 
+     private static void writePidFile(Path path) {
+         try {
+-            long l = ProcessHandle.current().pid();
+-            Files.writeString(path, Long.toString(l));
+-        } catch (IOException var3) {
+-            throw new UncheckedIOException(var3);
++            long i = ProcessHandle.current().pid();
++
++            Files.writeString(path, Long.toString(i));
++        } catch (IOException ioexception) {
++            throw new UncheckedIOException(ioexception);
+         }
+     }
+ 
+-    private static WorldLoader.InitConfig loadOrCreateConfig(
+-        DedicatedServerProperties dedicatedServerProperties, @Nullable Dynamic<?> dynamic, boolean flag, PackRepository packRepository
+-    ) {
++    private static WorldLoader.c loadOrCreateConfig(DedicatedServerProperties dedicatedserverproperties, @Nullable Dynamic<?> dynamic, boolean flag, PackRepository resourcepackrepository) {
+         boolean flag1;
+-        WorldDataConfiguration worldDataConfiguration;
++        WorldDataConfiguration worlddataconfiguration;
++
+         if (dynamic != null) {
+-            WorldDataConfiguration dataConfig = LevelStorageSource.readDataConfig(dynamic);
++            WorldDataConfiguration worlddataconfiguration1 = LevelStorageSource.readDataConfig(dynamic);
++
+             flag1 = false;
+-            worldDataConfiguration = dataConfig;
++            worlddataconfiguration = worlddataconfiguration1;
+         } else {
+             flag1 = true;
+-            worldDataConfiguration = new WorldDataConfiguration(dedicatedServerProperties.initialDataPackConfiguration, FeatureFlags.DEFAULT_FLAGS);
++            worlddataconfiguration = new WorldDataConfiguration(dedicatedserverproperties.initialDataPackConfiguration, FeatureFlags.DEFAULT_FLAGS);
+         }
+ 
+-        WorldLoader.PackConfig packConfig = new WorldLoader.PackConfig(packRepository, worldDataConfiguration, flag, flag1);
+-        return new WorldLoader.InitConfig(packConfig, Commands.CommandSelection.DEDICATED, dedicatedServerProperties.functionPermissionLevel);
++        WorldLoader.d worldloader_d = new WorldLoader.d(resourcepackrepository, worlddataconfiguration, flag, flag1);
++
++        return new WorldLoader.c(worldloader_d, Commands.CommandSelection.DEDICATED, dedicatedserverproperties.functionPermissionLevel);
+     }
+ 
+-    private static void forceUpgrade(
+-        LevelStorageSource.LevelStorageAccess levelStorage,
+-        DataFixer dataFixer,
+-        boolean eraseCache,
+-        BooleanSupplier upgradeWorld,
+-        Registry<LevelStem> dimesions
+-    ) {
+-        LOGGER.info("Forcing world upgrade!");
+-        WorldUpgrader worldUpgrader = new WorldUpgrader(levelStorage, dataFixer, dimesions, eraseCache);
+-        Component component = null;
++    public static void forceUpgrade(LevelStorageSource.LevelStorageAccess levelStorage, DataFixer dataFixer, boolean eraseCache, BooleanSupplier upgradeWorld, Registry<LevelStem> dimesions) {
++        Main.LOGGER.info("Forcing world upgrade! {}", levelStorage.getLevelId()); // CraftBukkit
++        WorldUpgrader worldupgrader = new WorldUpgrader(levelStorage, dataFixer, dimesions, eraseCache);
++        Component ichatbasecomponent = null;
+ 
+-        while (!worldUpgrader.isFinished()) {
+-            Component status = worldUpgrader.getStatus();
+-            if (component != status) {
+-                component = status;
+-                LOGGER.info(worldUpgrader.getStatus().getString());
++        while (!worldupgrader.isFinished()) {
++            Component ichatbasecomponent1 = worldupgrader.getStatus();
++
++            if (ichatbasecomponent != ichatbasecomponent1) {
++                ichatbasecomponent = ichatbasecomponent1;
++                Main.LOGGER.info(worldupgrader.getStatus().getString());
+             }
+ 
+-            int totalChunks = worldUpgrader.getTotalChunks();
+-            if (totalChunks > 0) {
+-                int i = worldUpgrader.getConverted() + worldUpgrader.getSkipped();
+-                LOGGER.info("{}% completed ({} / {} chunks)...", Mth.floor((float)i / (float)totalChunks * 100.0F), i, totalChunks);
++            int i = worldupgrader.getTotalChunks();
++
++            if (i > 0) {
++                int j = worldupgrader.getConverted() + worldupgrader.getSkipped();
++
++                Main.LOGGER.info("{}% completed ({} / {} chunks)...", new Object[]{Mth.floor((float) j / (float) i * 100.0F), j, i});
+             }
+ 
+             if (!upgradeWorld.getAsBoolean()) {
+-                worldUpgrader.cancel();
++                worldupgrader.cancel();
+             } else {
+                 try {
+                     Thread.sleep(1000L);
+-                } catch (InterruptedException var10) {
++                } catch (InterruptedException interruptedexception) {
++                    ;
+                 }
+             }
+         }
++
+     }
+ }