Paper/patches/server/0600-Fix-and-optimise-world-force-upgrading.patch

391 lines
20 KiB
Diff
Raw Normal View History

2021-06-11 14:02:28 +02:00
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Spottedleaf <Spottedleaf@users.noreply.github.com>
Date: Thu, 20 May 2021 07:02:22 -0700
Subject: [PATCH] Fix and optimise world force upgrading
The WorldUpgrader class was incorrectly modified by
CB. It will store an IChunkLoader instance for all
dimension types in the world, but obviously with how
CB shifts around worlds only one dimension type exists
per world. But this would be OK if CB did this
change correctly. All IChunkLoader instances
will point to the same regionfiles. And all
IChunkLoader instances are going to be read from.
This problem hasn't really been reported because
it relies on the persistent legacy data to be converted
as well to cause corruption. Why? Because the legacy
data is also shared, it will result in different
outputs from conversion (as once conversion for legacy
persistent data takes place, it is REMOVED - so the next
convert will _not_ have the data). Which means different
sizes on disk. Which means different regionfile sector
allocations. Which means there are 3 different possible
regionfile sector allocations in memory, and none of them
are going to be correct.
I've fixed this by writing a world upgrader suited to
CB's changes to world folder format. It was brain dead
easy to add threading, so I did.
== AT ==
public net.minecraft.util.worldupdate.WorldUpgrader REGEX
2021-06-11 14:02:28 +02:00
diff --git a/src/main/java/io/papermc/paper/world/ThreadedWorldUpgrader.java b/src/main/java/io/papermc/paper/world/ThreadedWorldUpgrader.java
new file mode 100644
2023-03-15 20:17:42 +01:00
index 0000000000000000000000000000000000000000..513833c2ea23df5b079d157bc5cb89d5c9754c0b
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/io/papermc/paper/world/ThreadedWorldUpgrader.java
2022-02-28 22:43:31 +01:00
@@ -0,0 +1,209 @@
2021-06-11 14:02:28 +02:00
+package io.papermc.paper.world;
+
+import com.mojang.datafixers.DataFixer;
2021-11-24 22:30:53 +01:00
+import com.mojang.serialization.Codec;
2021-06-11 14:02:28 +02:00
+import net.minecraft.SharedConstants;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.util.worldupdate.WorldUpgrader;
+import net.minecraft.world.level.ChunkPos;
2021-11-24 22:30:53 +01:00
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.chunk.ChunkGenerator;
2021-06-11 14:02:28 +02:00
+import net.minecraft.world.level.chunk.storage.ChunkStorage;
+import net.minecraft.world.level.chunk.storage.RegionFileStorage;
+import net.minecraft.world.level.dimension.DimensionType;
+import net.minecraft.world.level.dimension.LevelStem;
2021-11-24 22:30:53 +01:00
+import net.minecraft.world.level.levelgen.WorldGenSettings;
2021-06-11 14:02:28 +02:00
+import net.minecraft.world.level.storage.DimensionDataStorage;
+import net.minecraft.world.level.storage.LevelStorageSource;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import java.io.File;
+import java.io.IOException;
+import java.text.DecimalFormat;
2021-11-24 22:30:53 +01:00
+import java.util.Optional;
2021-06-11 14:02:28 +02:00
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Supplier;
+
+public class ThreadedWorldUpgrader {
+
+ private static final Logger LOGGER = LogManager.getLogger();
+
+ private final ResourceKey<LevelStem> dimensionType;
+ private final String worldName;
+ private final File worldDir;
2021-06-11 14:02:28 +02:00
+ private final ExecutorService threadPool;
+ private final DataFixer dataFixer;
2021-11-24 22:30:53 +01:00
+ private final Optional<ResourceKey<Codec<? extends ChunkGenerator>>> generatorKey;
2021-06-11 14:02:28 +02:00
+ private final boolean removeCaches;
+
2022-02-28 22:43:31 +01:00
+ public ThreadedWorldUpgrader(final ResourceKey<LevelStem> dimensionType, final String worldName, final File worldDir, final int threads,
2021-11-24 22:30:53 +01:00
+ final DataFixer dataFixer, final Optional<ResourceKey<Codec<? extends ChunkGenerator>>> generatorKey, final boolean removeCaches) {
2021-06-11 14:02:28 +02:00
+ this.dimensionType = dimensionType;
+ this.worldName = worldName;
+ this.worldDir = worldDir;
2021-06-11 14:02:28 +02:00
+ this.threadPool = Executors.newFixedThreadPool(Math.max(1, threads), new ThreadFactory() {
+ private final AtomicInteger threadCounter = new AtomicInteger();
+
+ @Override
+ public Thread newThread(final Runnable run) {
+ final Thread ret = new Thread(run);
+
+ ret.setName("World upgrader thread for world " + ThreadedWorldUpgrader.this.worldName + " #" + this.threadCounter.getAndIncrement());
+ ret.setUncaughtExceptionHandler((thread, throwable) -> {
+ LOGGER.fatal("Error upgrading world", throwable);
+ });
+
+ return ret;
+ }
+ });
+ this.dataFixer = dataFixer;
2021-11-24 22:30:53 +01:00
+ this.generatorKey = generatorKey;
2021-06-11 14:02:28 +02:00
+ this.removeCaches = removeCaches;
+ }
+
+ public void convert() {
2021-11-24 22:30:53 +01:00
+ final File worldFolder = LevelStorageSource.getStorageFolder(this.worldDir.toPath(), this.dimensionType).toFile();
2021-06-11 14:02:28 +02:00
+ final DimensionDataStorage worldPersistentData = new DimensionDataStorage(new File(worldFolder, "data"), this.dataFixer);
+
+ final File regionFolder = new File(worldFolder, "region");
+
+ LOGGER.info("Force upgrading " + this.worldName);
+ LOGGER.info("Counting regionfiles for " + this.worldName);
+ final File[] regionFiles = regionFolder.listFiles((final File dir, final String name) -> {
2021-06-15 04:59:31 +02:00
+ return WorldUpgrader.REGEX.matcher(name).matches();
2021-06-11 14:02:28 +02:00
+ });
+ if (regionFiles == null) {
+ LOGGER.info("Found no regionfiles to convert for world " + this.worldName);
+ return;
+ }
+ LOGGER.info("Found " + regionFiles.length + " regionfiles to convert");
+ LOGGER.info("Starting conversion now for world " + this.worldName);
+
+ final WorldInfo info = new WorldInfo(() -> worldPersistentData,
2021-11-24 22:30:53 +01:00
+ new ChunkStorage(regionFolder.toPath(), this.dataFixer, false), this.removeCaches, this.dimensionType, this.generatorKey);
2021-06-11 14:02:28 +02:00
+
+ long expectedChunks = (long)regionFiles.length * (32L * 32L);
+
+ for (final File regionFile : regionFiles) {
2021-11-24 22:30:53 +01:00
+ final ChunkPos regionPos = RegionFileStorage.getRegionFileCoordinates(regionFile.toPath());
2021-06-11 14:02:28 +02:00
+ if (regionPos == null) {
+ expectedChunks -= (32L * 32L);
+ continue;
+ }
+
+ this.threadPool.execute(new ConvertTask(info, regionPos.x >> 5, regionPos.z >> 5));
+ }
+ this.threadPool.shutdown();
+
+ final DecimalFormat format = new DecimalFormat("#0.00");
+
+ final long start = System.nanoTime();
+
+ while (!this.threadPool.isTerminated()) {
+ final long current = info.convertedChunks.get();
+
+ LOGGER.info("{}% completed ({} / {} chunks)...", format.format((double)current / (double)expectedChunks * 100.0), current, expectedChunks);
+
+ try {
+ Thread.sleep(1000L);
+ } catch (final InterruptedException ignore) {}
+ }
+
+ final long end = System.nanoTime();
+
+ try {
+ info.loader.close();
+ } catch (final IOException ex) {
+ LOGGER.fatal("Failed to close chunk loader", ex);
+ }
+ LOGGER.info("Completed conversion. Took {}s, {} out of {} chunks needed to be converted/modified ({}%)",
+ (int)Math.ceil((end - start) * 1.0e-9), info.modifiedChunks.get(), expectedChunks, format.format((double)info.modifiedChunks.get() / (double)expectedChunks * 100.0));
+ }
+
+ private static final class WorldInfo {
+
+ public final Supplier<DimensionDataStorage> persistentDataSupplier;
+ public final ChunkStorage loader;
+ public final boolean removeCaches;
2021-11-24 22:30:53 +01:00
+ public final ResourceKey<LevelStem> worldKey;
+ public final Optional<ResourceKey<Codec<? extends ChunkGenerator>>> generatorKey;
2021-06-11 14:02:28 +02:00
+ public final AtomicLong convertedChunks = new AtomicLong();
+ public final AtomicLong modifiedChunks = new AtomicLong();
+
+ private WorldInfo(final Supplier<DimensionDataStorage> persistentDataSupplier, final ChunkStorage loader, final boolean removeCaches,
2021-11-24 22:30:53 +01:00
+ final ResourceKey<LevelStem> worldKey, Optional<ResourceKey<Codec<? extends ChunkGenerator>>> generatorKey) {
2021-06-11 14:02:28 +02:00
+ this.persistentDataSupplier = persistentDataSupplier;
+ this.loader = loader;
+ this.removeCaches = removeCaches;
+ this.worldKey = worldKey;
2021-11-24 22:30:53 +01:00
+ this.generatorKey = generatorKey;
2021-06-11 14:02:28 +02:00
+ }
+ }
+
+ private static final class ConvertTask implements Runnable {
+
+ private final WorldInfo worldInfo;
+ private final int regionX;
+ private final int regionZ;
+
+ public ConvertTask(final WorldInfo worldInfo, final int regionX, final int regionZ) {
+ this.worldInfo = worldInfo;
+ this.regionX = regionX;
+ this.regionZ = regionZ;
+ }
+
+ @Override
+ public void run() {
+ final int regionCX = this.regionX << 5;
+ final int regionCZ = this.regionZ << 5;
+
+ final Supplier<DimensionDataStorage> persistentDataSupplier = this.worldInfo.persistentDataSupplier;
+ final ChunkStorage loader = this.worldInfo.loader;
+ final boolean removeCaches = this.worldInfo.removeCaches;
2021-11-24 22:30:53 +01:00
+ final ResourceKey<LevelStem> worldKey = this.worldInfo.worldKey;
2021-06-11 14:02:28 +02:00
+
+ for (int cz = regionCZ; cz < (regionCZ + 32); ++cz) {
+ for (int cx = regionCX; cx < (regionCX + 32); ++cx) {
+ final ChunkPos chunkPos = new ChunkPos(cx, cz);
+ try {
+ // no need to check the coordinate of the chunk, the regionfilecache does that for us
+
2022-06-08 16:24:55 +02:00
+ CompoundTag chunkNBT = (loader.read(chunkPos).join()).orElse(null);
2021-06-11 14:02:28 +02:00
+
+ if (chunkNBT == null) {
+ continue;
+ }
+
+ final int versionBefore = ChunkStorage.getVersion(chunkNBT);
+
2021-11-24 22:30:53 +01:00
+ chunkNBT = loader.upgradeChunkTag(worldKey, persistentDataSupplier, chunkNBT, this.worldInfo.generatorKey, chunkPos, null);
2021-06-11 14:02:28 +02:00
+
2023-03-15 20:17:42 +01:00
+ boolean modified = versionBefore < SharedConstants.getCurrentVersion().getDataVersion().getVersion();
2021-06-11 14:02:28 +02:00
+
+ if (removeCaches) {
+ final CompoundTag level = chunkNBT.getCompound("Level");
+ modified |= level.contains("Heightmaps");
+ level.remove("Heightmaps");
+ modified |= level.contains("isLightOn");
+ level.remove("isLightOn");
+ }
+
+ if (modified) {
+ this.worldInfo.modifiedChunks.getAndIncrement();
+ loader.write(chunkPos, chunkNBT);
+ }
+ } catch (final Exception ex) {
+ LOGGER.error("Error upgrading chunk {}", chunkPos, ex);
+ } finally {
+ this.worldInfo.convertedChunks.getAndIncrement();
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/Main.java b/src/main/java/net/minecraft/server/Main.java
2023-09-22 22:13:57 +02:00
index 0ea4b588ae7426c59a47ec30e39c878c5fe3df85..963e9887bda7bbcd9555fcbb17d63362ef1be5a6 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/net/minecraft/server/Main.java
+++ b/src/main/java/net/minecraft/server/Main.java
2023-09-22 07:41:27 +02:00
@@ -16,6 +16,7 @@ import java.nio.file.Path;
import java.nio.file.Paths;
2021-06-11 14:02:28 +02:00
import java.util.Optional;
import java.util.function.BooleanSupplier;
+import io.papermc.paper.world.ThreadedWorldUpgrader;
import joptsimple.NonOptionArgumentSpec;
import joptsimple.OptionParser;
import joptsimple.OptionSet;
2023-09-22 22:13:57 +02:00
@@ -358,6 +359,15 @@ public class Main {
2022-12-07 21:16:54 +01:00
return new WorldLoader.InitConfig(worldloader_d, Commands.CommandSelection.DEDICATED, serverPropertiesHandler.functionPermissionLevel);
2021-06-11 14:02:28 +02:00
}
+ // Paper start - fix and optimise world upgrading
2022-02-28 22:43:31 +01:00
+ public static void convertWorldButItWorks(net.minecraft.resources.ResourceKey<net.minecraft.world.level.dimension.LevelStem> dimensionType, net.minecraft.world.level.storage.LevelStorageSource.LevelStorageAccess worldSession,
2021-11-24 22:30:53 +01:00
+ DataFixer dataFixer, Optional<net.minecraft.resources.ResourceKey<com.mojang.serialization.Codec<? extends net.minecraft.world.level.chunk.ChunkGenerator>>> generatorKey, boolean removeCaches) {
2021-06-11 14:02:28 +02:00
+ int threads = Runtime.getRuntime().availableProcessors() * 3 / 8;
2022-06-08 14:19:54 +02:00
+ final ThreadedWorldUpgrader worldUpgrader = new ThreadedWorldUpgrader(dimensionType, worldSession.getLevelId(), worldSession.levelDirectory.path().toFile(), threads, dataFixer, generatorKey, removeCaches);
2021-06-11 14:02:28 +02:00
+ worldUpgrader.convert();
+ }
+ // Paper end - fix and optimise world upgrading
+
2022-12-07 21:16:54 +01:00
public static void forceUpgrade(LevelStorageSource.LevelStorageAccess session, DataFixer dataFixer, boolean eraseCache, BooleanSupplier continueCheck, Registry<LevelStem> dimensionOptionsRegistry) {
2021-06-11 14:02:28 +02:00
Main.LOGGER.info("Forcing world upgrade! {}", session.getLevelId()); // CraftBukkit
2022-12-07 21:16:54 +01:00
WorldUpgrader worldupgrader = new WorldUpgrader(session, dataFixer, dimensionOptionsRegistry, eraseCache);
2021-06-11 14:02:28 +02:00
diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
2023-10-27 01:34:58 +02:00
index 992aa1fa85f0b0240d317773be5086e64889996a..1400fd3f8eb38c15e85221b5805080e1d792215f 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
2023-09-22 07:41:27 +02:00
@@ -540,11 +540,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
2022-12-07 21:16:54 +01:00
worlddata = new PrimaryLevelData(worldsettings, worldoptions, worlddimensions_b.specialWorldProperty(), lifecycle);
2021-06-11 14:02:28 +02:00
}
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)
2021-06-15 04:59:31 +02:00
- if (this.options.has("forceUpgrade")) {
- net.minecraft.server.Main.forceUpgrade(worldSession, DataFixers.getDataFixer(), this.options.has("eraseCache"), () -> {
2021-06-11 14:02:28 +02:00
- return true;
Updated Upstream (Bukkit/CraftBukkit) (#9485) Upstream has released updates that appear to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: 82af5dc6 SPIGOT-7396: Add PlayerSignOpenEvent 3f0281ca SPIGOT-7063, PR-763: Add DragonBattle#initiateRespawn with custom EnderCrystals f83c8df4 PR-873: Add PlayerRecipeBookClickEvent 14560d39 SPIGOT-7435: Add TeleportCause#EXIT_BED 2cc6db92 SPIGOT-7422, PR-887: Add API to set sherds on decorated pots 36022f02 PR-883: Add ItemFactory#getSpawnEgg 12eb5c46 PR-881: Update Scoreboard Javadocs, remove explicit exception throwing f6d8d44a PR-882: Add modern time API methods to ban API 21a7b710 Upgrade some Maven plugins to reduce warnings 11fd1225 PR-886: Deprecate the SmithingRecipe constructor as it now does nothing dbd1761d SPIGOT-7406: Improve documentation for getDragonBattle CraftBukkit Changes: d548daac2 SPIGOT-7446: BlockState#update not updating a spawner's type to null 70e0bc050 SPIGOT-7447: Fix --forceUpgrade 6752f1d63 SPIGOT-7396: Add PlayerSignOpenEvent 847b4cad5 SPIGOT-7063, PR-1071: Add DragonBattle#initiateRespawn with custom EnderCrystals c335a555f PR-1212: Add PlayerRecipeBookClickEvent 4be756ecb SPIGOT-7445: Fix opening smithing inventory db70bd6ed SPIGOT-7441: Fix issue placing certain items in creative/op f7fa6d993 SPIGOT-7435: Add TeleportCause#EXIT_BED b435e8e8d SPIGOT-7349: Player#setDisplayName not working when message/format unmodified a2fafdd1d PR-1232: Re-add fix for player rotation 7cf863de1 PR-1233: Remove some old MC bug fixes now fixed in vanilla 08ec344ad Fix ChunkGenerator#generateCaves never being called 5daeb502a SPIGOT-7422, PR-1228: Add API to set sherds on decorated pots 52faa6b32 PR-1224: Add ItemFactory#getSpawnEgg 01cae71b7 SPIGOT-7429: Fix LEFT_CLICK_AIR not working for passable entities and spectators a94277a18 PR-1223: Remove non-existent scoreboard display name/prefix/suffix limits 36b107660 PR-1225: Add modern time API methods to ban API 59ead25bc Upgrade some Maven plugins to reduce warnings 202fc5c4e Increase outdated build delay ce545de57 SPIGOT-7398: TextDisplay#setInterpolationDuration incorrectly updates the line width Spigot Changes: b41c46db Rebuild patches 3374045a SPIGOT-7431: Fix EntityMountEvent returning opposite entities 0ca4eb66 Rebuild patches
2023-08-06 02:21:59 +02:00
- }, dimensions);
2021-06-11 14:02:28 +02:00
- }
+ // Paper - move down
2022-06-08 11:31:06 +02:00
PrimaryLevelData iworlddataserver = worlddata;
2022-12-07 21:16:54 +01:00
boolean flag = worlddata.isDebugWorld();
2023-09-22 07:41:27 +02:00
@@ -559,6 +555,13 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
2022-06-08 11:31:06 +02:00
biomeProvider = gen.getDefaultBiomeProvider(worldInfo);
2021-06-11 14:02:28 +02:00
}
+ // Paper start - fix and optimise world upgrading
+ if (options.has("forceUpgrade")) {
+ net.minecraft.server.Main.convertWorldButItWorks(
2022-06-08 11:31:06 +02:00
+ dimensionKey, worldSession, DataFixers.getDataFixer(), worlddimension.generator().getTypeNameForDataFixer(), options.has("eraseCache")
2021-06-11 14:02:28 +02:00
+ );
+ }
+ // Paper end - fix and optimise world upgrading
2022-12-07 21:16:54 +01:00
ResourceKey<Level> worldKey = ResourceKey.create(Registries.DIMENSION, dimensionKey.location());
2021-06-11 14:02:28 +02:00
if (dimensionKey == LevelStem.OVERWORLD) {
diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
2023-10-27 01:34:58 +02:00
index e22214b99472b23ffc95c011b19bdb59e2d9bb40..b3833da06ec8882f09b01fc596eafe519f0873c1 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
@@ -184,6 +184,15 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
2021-06-15 15:20:52 +02:00
public final Map<Explosion.CacheKey, Float> explosionDensityCache = new HashMap<>(); // Paper - Optimize explosions
public java.util.ArrayDeque<net.minecraft.world.level.block.RedstoneTorchBlock.Toggle> redstoneUpdateInfos; // Paper - Move from Map in BlockRedstoneTorch to here
2021-06-11 14:02:28 +02:00
+ // Paper start - fix and optimise world upgrading
+ // copied from below
+ public static ResourceKey<DimensionType> getDimensionKey(DimensionType manager) {
2022-12-08 04:24:00 +01:00
+ return ((org.bukkit.craftbukkit.CraftServer)org.bukkit.Bukkit.getServer()).getHandle().getServer().registryAccess().registryOrThrow(net.minecraft.core.registries.Registries.DIMENSION_TYPE).getResourceKey(manager).orElseThrow(() -> {
2021-06-11 14:02:28 +02:00
+ return new IllegalStateException("Unregistered dimension type: " + manager);
+ });
+ }
+ // Paper end - fix and optimise world upgrading
2021-06-15 15:20:52 +02:00
+
public CraftWorld getWorld() {
return this.world;
}
2021-06-11 14:02:28 +02:00
diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
2023-09-22 22:13:57 +02:00
index b850dba2b0fa5bc762b170ed7083cf8904761f17..7dee0f7d49f3492c92fceff7750e696239f840ed 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
+++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
2023-09-22 22:13:57 +02:00
@@ -60,6 +60,29 @@ public class RegionFileStorage implements AutoCloseable {
2021-06-15 04:59:31 +02:00
}
2021-06-11 14:02:28 +02:00
2023-09-22 22:13:57 +02:00
// Paper start
2023-06-08 03:13:54 +02:00
+ @Nullable
+ public static ChunkPos getRegionFileCoordinates(Path file) {
2021-11-24 22:30:53 +01:00
+ String fileName = file.getFileName().toString();
2021-06-11 14:02:28 +02:00
+ if (!fileName.startsWith("r.") || !fileName.endsWith(".mca")) {
+ return null;
+ }
+
+ String[] split = fileName.split("\\.");
+
+ if (split.length != 4) {
+ return null;
+ }
+
+ try {
+ int x = Integer.parseInt(split[1]);
+ int z = Integer.parseInt(split[2]);
+
+ return new ChunkPos(x << 5, z << 5);
+ } catch (NumberFormatException ex) {
+ return null;
+ }
+ }
2023-09-22 22:13:57 +02:00
+
public synchronized RegionFile getRegionFileIfLoaded(ChunkPos chunkcoordintpair) {
return this.regionCache.getAndMoveToFirst(ChunkPos.asLong(chunkcoordintpair.getRegionX(), chunkcoordintpair.getRegionZ()));
}
2021-06-11 14:02:28 +02:00
diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
index 4f6ba50ec5852b12fdb1b74a04f74e706e3019aa..56c0677cab4ca77bbcf853a57d5bacc0042adb74 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
@@ -1218,9 +1218,7 @@ public final class CraftServer implements Server {
2021-06-11 14:02:28 +02:00
worlddata.checkName(name);
2021-11-24 22:30:53 +01:00
worlddata.setModdedInfo(this.console.getServerModName(), this.console.getModdedStatus().shouldReportAsModified());
2023-10-27 01:34:58 +02:00
- if (this.console.options.has("forceUpgrade")) {
- net.minecraft.server.Main.forceUpgrade(worldSession, DataFixers.getDataFixer(), this.console.options.has("eraseCache"), () -> true, iregistry);
2021-06-11 14:02:28 +02:00
- }
+ // Paper - move down
long j = BiomeManager.obfuscateSeed(creator.seed());
List<CustomSpawner> list = ImmutableList.of(new PhantomSpawner(), new PatrolSpawner(), new CatSpawner(), new VillageSiege(), new WanderingTraderSpawner(worlddata));
@@ -1231,6 +1229,13 @@ public final class CraftServer implements Server {
2022-06-08 11:31:06 +02:00
biomeProvider = generator.getDefaultBiomeProvider(worldInfo);
2021-06-11 14:02:28 +02:00
}
+ // Paper start - fix and optimise world upgrading
2023-10-27 01:34:58 +02:00
+ if (this.console.options.has("forceUpgrade")) {
2021-06-11 14:02:28 +02:00
+ net.minecraft.server.Main.convertWorldButItWorks(
2023-10-27 01:34:58 +02:00
+ actualDimension, worldSession, DataFixers.getDataFixer(), worlddimension.generator().getTypeNameForDataFixer(), this.console.options.has("eraseCache")
2021-06-11 14:02:28 +02:00
+ );
+ }
+ // Paper end - fix and optimise world upgrading
ResourceKey<net.minecraft.world.level.Level> worldKey;
String levelName = this.getServer().getProperties().levelName;
if (name.equals(levelName + "_nether")) {