aboutsummaryrefslogtreecommitdiffhomepage
path: root/patch-remap/mache-vineflower/net/minecraft/server/Main.java.patch
diff options
context:
space:
mode:
Diffstat (limited to 'patch-remap/mache-vineflower/net/minecraft/server/Main.java.patch')
-rw-r--r--patch-remap/mache-vineflower/net/minecraft/server/Main.java.patch550
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) {
++ ;
+ }
+ }
+ }
++
+ }
+ }
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-25 05:24:06 +0000