twin/paper-mc
1
0
Fork 0
mirror of https://github.com/PaperMC/Paper.git synced 2025-07-31 20:22:05 -07:00
Code Issues Packages Projects Releases Wiki Activity

more patches updated

Browse Source
This commit is contained in:
Jake Potrebic
2021-11-23 20:25:34 -08:00
parent 2b25404eca
commit f629237348
8 changed files with 50 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
patches/unapplied/api/Expose-the-internal-current-tick.patch → patches/api/Expose-the-internal-current-tick.patch
View File

0
patches/unapplied/api/Increase-custom-payload-channel-message-size.patch → patches/api/Increase-custom-payload-channel-message-size.patch
View File

49
patches/unapplied/server/Allow-Saving-of-Oversized-Chunks.patch → patches/server/Allow-Saving-of-Oversized-Chunks.patch
View File

@@ -53,15 +53,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
@VisibleForTesting @VisibleForTesting
protected final RegionBitmap usedSectors; protected final RegionBitmap usedSectors;
public final java.util.concurrent.locks.ReentrantLock fileLock = new java.util.concurrent.locks.ReentrantLock(true); // Paper public final java.util.concurrent.locks.ReentrantLock fileLock = new java.util.concurrent.locks.ReentrantLock(true); // Paper
+ public final File regionFile; // Paper + public final Path regionFile; // Paper
public RegionFile(File file, File directory, boolean dsync) throws IOException { public RegionFile(Path path, Path path1, boolean dsync) throws IOException {
this(file.toPath(), directory.toPath(), RegionFileVersion.VERSION_DEFLATE, dsync); this(path, path1, RegionFileVersion.VERSION_DEFLATE, dsync);
@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable { @@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable {
public RegionFile(Path file, Path directory, RegionFileVersion outputChunkStreamVersion, boolean dsync) throws IOException { public RegionFile(Path file, Path directory, RegionFileVersion outputChunkStreamVersion, boolean dsync) throws IOException {
this.header = ByteBuffer.allocateDirect(8192); this.header = ByteBuffer.allocateDirect(8192);
+ this.regionFile = file.toFile(); // Paper + this.regionFile = file; // Paper
+ initOversizedState(); // Paper + initOversizedState(); // Paper
this.usedSectors = new RegionBitmap(); this.usedSectors = new RegionBitmap();
this.version = outputChunkStreamVersion; this.version = outputChunkStreamVersion;
@@ -75,9 +75,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ private int oversizedCount = 0; + private int oversizedCount = 0;
+ +
+ private synchronized void initOversizedState() throws IOException { + private synchronized void initOversizedState() throws IOException {
+ File metaFile = getOversizedMetaFile(); + Path metaFile = getOversizedMetaFile();
+ if (metaFile.exists()) { + if (Files.exists(metaFile)) {
+ final byte[] read = java.nio.file.Files.readAllBytes(metaFile.toPath()); + final byte[] read = java.nio.file.Files.readAllBytes(metaFile);
+ System.arraycopy(read, 0, oversized, 0, oversized.length); + System.arraycopy(read, 0, oversized, 0, oversized.length);
+ for (byte temp : oversized) { + for (byte temp : oversized) {
+ oversizedCount += temp; + oversizedCount += temp;
@@ -101,9 +101,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ oversizedCount--; + oversizedCount--;
+ } + }
+ if (previous && !oversized) { + if (previous && !oversized) {
+ File oversizedFile = getOversizedFile(x, z); + Path oversizedFile = getOversizedFile(x, z);
+ if (oversizedFile.exists()) { + if (Files.exists(oversizedFile)) {
+ oversizedFile.delete(); + Files.delete(oversizedFile);
+ } + }
+ } + }
+ if (oversizedCount > 0) { + if (oversizedCount > 0) {
@@ -111,28 +111,28 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ writeOversizedMeta(); + writeOversizedMeta();
+ } + }
+ } else if (previous) { + } else if (previous) {
+ File oversizedMetaFile = getOversizedMetaFile(); + Path oversizedMetaFile = getOversizedMetaFile();
+ if (oversizedMetaFile.exists()) { + if (Files.exists(oversizedMetaFile)) {
+ oversizedMetaFile.delete(); + Files.delete(oversizedMetaFile);
+ } + }
+ } + }
+ } + }
+ +
+ private void writeOversizedMeta() throws IOException { + private void writeOversizedMeta() throws IOException {
+ java.nio.file.Files.write(getOversizedMetaFile().toPath(), oversized); + java.nio.file.Files.write(getOversizedMetaFile(), oversized);
+ } + }
+ +
+ private File getOversizedMetaFile() { + private Path getOversizedMetaFile() {
+ return new File(this.regionFile.getParentFile(), this.regionFile.getName().replaceAll("\\.mca$", "") + ".oversized.nbt"); + return this.regionFile.getParent().resolve(this.regionFile.getFileName().toString().replaceAll("\\.mca$", "") + ".oversized.nbt");
+ } + }
+ +
+ private File getOversizedFile(int x, int z) { + private Path getOversizedFile(int x, int z) {
+ return new File(this.regionFile.getParentFile(), this.regionFile.getName().replaceAll("\\.mca$", "") + "_oversized_" + x + "_" + z + ".nbt"); + return this.regionFile.getParent().resolve(this.regionFile.getFileName().toString().replaceAll("\\.mca$", "") + "_oversized_" + x + "_" + z + ".nbt");
+ } + }
+ +
+ synchronized CompoundTag getOversizedData(int x, int z) throws IOException { + synchronized CompoundTag getOversizedData(int x, int z) throws IOException {
+ File file = getOversizedFile(x, z); + Path file = getOversizedFile(x, z);
+ try (DataInputStream out = new DataInputStream(new BufferedInputStream(new InflaterInputStream(new java.io.FileInputStream(file))))) { + try (DataInputStream out = new DataInputStream(new java.io.BufferedInputStream(new InflaterInputStream(Files.newInputStream(file))))) {
+ return NbtIo.read((java.io.DataInput) out); + return NbtIo.read((java.io.DataInput) out);
+ } + }
+ +
@@ -145,22 +145,23 @@ diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileSto
index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java --- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
+++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java +++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
@@ -0,0 +0,0 @@ import java.io.File; @@ -0,0 +0,0 @@ import java.nio.file.Files;
import java.io.IOException; import java.nio.file.Path;
import javax.annotation.Nullable; import javax.annotation.Nullable;
import net.minecraft.nbt.CompoundTag; import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag; +import net.minecraft.nbt.ListTag;
import net.minecraft.nbt.NbtIo; import net.minecraft.nbt.NbtIo;
import net.minecraft.nbt.StreamTagVisitor;
+import net.minecraft.nbt.Tag; +import net.minecraft.nbt.Tag;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.ExceptionCollector; import net.minecraft.util.ExceptionCollector;
import net.minecraft.world.level.ChunkPos; import net.minecraft.world.level.ChunkPos;
@@ -0,0 +0,0 @@ public class RegionFileStorage implements AutoCloseable { @@ -0,0 +0,0 @@ public class RegionFileStorage implements AutoCloseable {
} }
} }
+ // Paper start + // Paper start
+ private static void printOversizedLog(String msg, File file, int x, int z) { + private static void printOversizedLog(String msg, Path file, int x, int z) {
+ org.apache.logging.log4j.LogManager.getLogger().fatal(msg + " (" + file.toString().replaceAll(".+[\\\\/]", "") + " - " + x + "," + z + ") Go clean it up to remove this message. /minecraft:tp " + (x<<4)+" 128 "+(z<<4) + " - DO NOT REPORT THIS TO PAPER - You may ask for help on Discord, but do not file an issue. These error messages can not be removed."); + org.apache.logging.log4j.LogManager.getLogger().fatal(msg + " (" + file.toString().replaceAll(".+[\\\\/]", "") + " - " + x + "," + z + ") Go clean it up to remove this message. /minecraft:tp " + (x<<4)+" 128 "+(z<<4) + " - DO NOT REPORT THIS TO PAPER - You may ask for help on Discord, but do not file an issue. These error messages can not be removed.");
+ } + }
+ +

0
patches/unapplied/server/Chunk-debug-command.patch → patches/server/Chunk-debug-command.patch
View File

6
patches/unapplied/server/ChunkMapDistance-CME.patch → patches/server/ChunkMapDistance-CME.patch
View File

@@ -21,8 +21,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
--- a/src/main/java/net/minecraft/server/level/DistanceManager.java --- a/src/main/java/net/minecraft/server/level/DistanceManager.java
+++ b/src/main/java/net/minecraft/server/level/DistanceManager.java +++ b/src/main/java/net/minecraft/server/level/DistanceManager.java
@@ -0,0 +0,0 @@ public abstract class DistanceManager { @@ -0,0 +0,0 @@ public abstract class DistanceManager {
private final DistanceManager.ChunkTicketTracker ticketTracker = new DistanceManager.ChunkTicketTracker();
private final DistanceManager.FixedPlayerDistanceChunkTracker naturalSpawnChunkCounter = new DistanceManager.FixedPlayerDistanceChunkTracker(8); private final DistanceManager.FixedPlayerDistanceChunkTracker naturalSpawnChunkCounter = new DistanceManager.FixedPlayerDistanceChunkTracker(8);
private final TickingTracker tickingTicketsTracker = new TickingTracker();
private final DistanceManager.PlayerTicketTracker playerTicketManager = new DistanceManager.PlayerTicketTracker(33); private final DistanceManager.PlayerTicketTracker playerTicketManager = new DistanceManager.PlayerTicketTracker(33);
- final Set<ChunkHolder> chunksToUpdateFutures = Sets.newHashSet(); - final Set<ChunkHolder> chunksToUpdateFutures = Sets.newHashSet();
+ // Paper start use a queue, but still keep unique requirement + // Paper start use a queue, but still keep unique requirement
@@ -52,7 +52,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
- iter.remove(); - iter.remove();
- expectedSize--; - expectedSize--;
- -
- playerchunk.updateFutures(playerchunkmap, this.mainThreadExecutor); - playerchunk.updateFutures(chunkStorage, this.mainThreadExecutor);
- -
- // Reset iterator if set was modified using add() - // Reset iterator if set was modified using add()
- if (this.chunksToUpdateFutures.size() != expectedSize) { - if (this.chunksToUpdateFutures.size() != expectedSize) {
@@ -67,7 +67,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ while(!this.pendingChunkUpdates.isEmpty()) { + while(!this.pendingChunkUpdates.isEmpty()) {
+ ChunkHolder remove = this.pendingChunkUpdates.remove(); + ChunkHolder remove = this.pendingChunkUpdates.remove();
+ remove.isUpdateQueued = false; + remove.isUpdateQueued = false;
+ remove.updateFutures(playerchunkmap, this.mainThreadExecutor); + remove.updateFutures(chunkStorage, this.mainThreadExecutor);
+ } + }
+ // Paper end + // Paper end
return true; return true;

14
patches/unapplied/server/Configurable-Keep-Spawn-Loaded-range-per-world.patch → patches/server/Configurable-Keep-Spawn-Loaded-range-per-world.patch
View File

@@ -29,13 +29,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
// CraftBukkit start // CraftBukkit start
public void loadSpawn(ChunkProgressListener worldloadlistener, ServerLevel worldserver) { public void prepareLevels(ChunkProgressListener worldloadlistener, ServerLevel worldserver) {
- if (!worldserver.getWorld().getKeepSpawnInMemory()) { - if (!worldserver.getWorld().getKeepSpawnInMemory()) {
- return; - return;
- } - }
+ ServerChunkCache chunkproviderserver = worldserver.getChunkSource(); // Paper + ServerChunkCache chunkproviderserver = worldserver.getChunkSource(); // Paper
// WorldServer worldserver = this.E(); // WorldServer worldserver = this.overworld();
this.forceTicks = true; this.forceTicks = true;
// CraftBukkit end // CraftBukkit end
+ if (worldserver.getWorld().getKeepSpawnInMemory()) { // Paper + if (worldserver.getWorld().getKeepSpawnInMemory()) { // Paper
@@ -53,7 +53,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
- -
- while (chunkproviderserver.getTickingGenerated() != 441) { - while (chunkproviderserver.getTickingGenerated() != 441) {
- // CraftBukkit start - // CraftBukkit start
- // this.nextTickTime = SystemUtils.getMonotonicMillis() + 10L; - // this.nextTickTime = SystemUtils.getMillis() + 10L;
- this.executeModerately(); - this.executeModerately();
- // CraftBukkit end - // CraftBukkit end
- } - }
@@ -68,22 +68,22 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ // Paper end + // Paper end
// CraftBukkit start // CraftBukkit start
// this.nextTickTime = SystemUtils.getMonotonicMillis() + 10L; // this.nextTickTime = SystemUtils.getMillis() + 10L;
this.executeModerately(); this.executeModerately();
// Iterator iterator = this.worldServer.values().iterator(); // Iterator iterator = this.levels.values().iterator();
+ } + }
if (true) { if (true) {
ServerLevel worldserver1 = worldserver; ServerLevel worldserver1 = worldserver;
@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
// this.nextTick = SystemUtils.getMonotonicMillis() + 10L; // this.nextTickTime = SystemUtils.getMillis() + 10L;
this.executeModerately(); this.executeModerately();
// CraftBukkit end // CraftBukkit end
- worldloadlistener.stop(); - worldloadlistener.stop();
+ if (worldserver.getWorld().getKeepSpawnInMemory()) worldloadlistener.stop(); // Paper + if (worldserver.getWorld().getKeepSpawnInMemory()) worldloadlistener.stop(); // Paper
chunkproviderserver.getLightEngine().setTaskPerBatch(5); chunkproviderserver.getLightEngine().setTaskPerBatch(5);
// CraftBukkit start // CraftBukkit start
// this.updateSpawnFlags(); // this.updateMobSpawningFlags();
diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerLevel.java --- a/src/main/java/net/minecraft/server/level/ServerLevel.java

0
patches/unapplied/server/Expose-the-internal-current-tick.patch → patches/server/Expose-the-internal-current-tick.patch
View File

66
patches/unapplied/server/Fix-World-isChunkGenerated-calls.patch → patches/server/Fix-World-isChunkGenerated-calls.patch
View File

@@ -7,30 +7,6 @@ Optimize World#loadChunk() too
This patch also adds a chunk status cache on region files (note that This patch also adds a chunk status cache on region files (note that
its only purpose is to cache the status on DISK) its only purpose is to cache the status on DISK)
diff --git a/src/main/java/net/minecraft/server/level/ChunkHolder.java b/src/main/java/net/minecraft/server/level/ChunkHolder.java
index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ChunkHolder.java
+++ b/src/main/java/net/minecraft/server/level/ChunkHolder.java
@@ -0,0 +0,0 @@ public class ChunkHolder {
Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure> either = (Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>) statusFuture.getNow(null);
return (either == null) ? null : (LevelChunk) either.left().orElse(null);
}
+
+ public ChunkAccess getAvailableChunkNow() {
+ // TODO can we just getStatusFuture(EMPTY)?
+ for (ChunkStatus curr = ChunkStatus.FULL, next = curr.getParent(); curr != next; curr = next, next = next.getParent()) {
+ CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>> future = this.getFutureIfPresentUnchecked(curr);
+ Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure> either = future.getNow(null);
+ if (either == null || !either.left().isPresent()) {
+ continue;
+ }
+ return either.left().get();
+ }
+ return null;
+ }
// CraftBukkit end
public CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>> getFutureIfPresentUnchecked(ChunkStatus leastStatus) {
diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ChunkMap.java --- a/src/main/java/net/minecraft/server/level/ChunkMap.java
@@ -41,8 +17,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
import net.minecraft.world.level.chunk.storage.ChunkStorage; import net.minecraft.world.level.chunk.storage.ChunkStorage;
+import net.minecraft.world.level.chunk.storage.RegionFile; +import net.minecraft.world.level.chunk.storage.RegionFile;
import net.minecraft.world.level.entity.ChunkStatusUpdateListener; import net.minecraft.world.level.entity.ChunkStatusUpdateListener;
import net.minecraft.world.level.levelgen.blending.BlendingData;
import net.minecraft.world.level.levelgen.structure.StructureStart; import net.minecraft.world.level.levelgen.structure.StructureStart;
import net.minecraft.world.level.levelgen.structure.templatesystem.StructureManager;
@@ -0,0 +0,0 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider @@ -0,0 +0,0 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
@Nullable @Nullable
public CompoundTag readChunk(ChunkPos pos) throws IOException { public CompoundTag readChunk(ChunkPos pos) throws IOException {
@@ -52,7 +28,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ return null; + return null;
+ } + }
+ +
+ nbttagcompound = this.getChunkData(this.level.getTypeKey(), this.overworldDataStorage, nbttagcompound, pos, level); // CraftBukkit + nbttagcompound = this.upgradeChunkTag(this.level.getTypeKey(), this.overworldDataStorage, nbttagcompound, this.generator.getTypeNameForDataFixer(), pos, level); // CraftBukkit
+ if (nbttagcompound == null) { + if (nbttagcompound == null) {
+ return null; + return null;
+ } + }
@@ -67,12 +43,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ public ChunkStatus getChunkStatusOnDiskIfCached(ChunkPos chunkPos) { + public ChunkStatus getChunkStatusOnDiskIfCached(ChunkPos chunkPos) {
+ RegionFile regionFile = regionFileCache.getRegionFileIfLoaded(chunkPos); + RegionFile regionFile = regionFileCache.getRegionFileIfLoaded(chunkPos);
- return nbttagcompound == null ? null : this.getChunkData(this.level.getTypeKey(), this.overworldDataStorage, nbttagcompound, pos, level); // CraftBukkit - return nbttagcompound == null ? null : this.upgradeChunkTag(this.level.getTypeKey(), this.overworldDataStorage, nbttagcompound, this.generator.getTypeNameForDataFixer(), pos, level); // CraftBukkit
+ return regionFile == null ? null : regionFile.getStatusIfCached(chunkPos.x, chunkPos.z); + return regionFile == null ? null : regionFile.getStatusIfCached(chunkPos.x, chunkPos.z);
} }
+ public ChunkStatus getChunkStatusOnDisk(ChunkPos chunkPos) throws IOException { + public ChunkStatus getChunkStatusOnDisk(ChunkPos chunkPos) throws IOException {
+ RegionFile regionFile = regionFileCache.getFile(chunkPos, true); + RegionFile regionFile = regionFileCache.getRegionFile(chunkPos, true);
+ +
+ if (regionFile == null || !regionFileCache.chunkExists(chunkPos)) { + if (regionFile == null || !regionFileCache.chunkExists(chunkPos)) {
+ return null; + return null;
@@ -90,7 +66,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ } + }
+ +
+ public void updateChunkStatusOnDisk(ChunkPos chunkPos, @Nullable CompoundTag compound) throws IOException { + public void updateChunkStatusOnDisk(ChunkPos chunkPos, @Nullable CompoundTag compound) throws IOException {
+ RegionFile regionFile = regionFileCache.getFile(chunkPos, false); + RegionFile regionFile = regionFileCache.getRegionFile(chunkPos, false);
+ +
+ regionFile.setStatus(chunkPos.x, chunkPos.z, ChunkSerializer.getStatus(compound)); + regionFile.setStatus(chunkPos.x, chunkPos.z, ChunkSerializer.getStatus(compound));
+ } + }
@@ -101,21 +77,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ } + }
+ // Paper end + // Paper end
+ +
boolean noPlayersCloseForSpawning(ChunkPos chunkPos) { boolean anyPlayerCloseEnoughForSpawning(ChunkPos pos) {
// Spigot start // Spigot start
return this.isOutsideOfRange(chunkPos, false); return this.anyPlayerCloseEnoughForSpawning(pos, false);
diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
}
// Paper end
// Paper start - async chunk io
+ @Nullable
public ChunkAccess getChunkAtImmediately(int x, int z) {
ChunkHolder holder = this.chunkMap.getVisibleChunkIfPresent(ChunkPos.asLong(x, z));
if (holder == null) {
diff --git a/src/main/java/net/minecraft/world/level/chunk/ChunkStatus.java b/src/main/java/net/minecraft/world/level/chunk/ChunkStatus.java diff --git a/src/main/java/net/minecraft/world/level/chunk/ChunkStatus.java b/src/main/java/net/minecraft/world/level/chunk/ChunkStatus.java
index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/chunk/ChunkStatus.java --- a/src/main/java/net/minecraft/world/level/chunk/ChunkStatus.java
@@ -143,11 +107,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
--- a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java --- a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java
+++ b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java +++ b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java
@@ -0,0 +0,0 @@ public class ChunkSerializer { @@ -0,0 +0,0 @@ public class ChunkSerializer {
return nbttagcompound; }));
} }
+ // Paper start + // Paper start
+ public static ChunkStatus getStatus(CompoundTag compound) { + public static @Nullable ChunkStatus getStatus(@Nullable CompoundTag compound) {
+ if (compound == null) { + if (compound == null) {
+ return null; + return null;
+ } + }
@@ -158,8 +122,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ // Paper end + // Paper end
+ +
public static ChunkStatus.ChunkType getChunkTypeFromTag(@Nullable CompoundTag nbt) { public static ChunkStatus.ChunkType getChunkTypeFromTag(@Nullable CompoundTag nbt) {
if (nbt != null) { return nbt != null ? ChunkStatus.byName(nbt.getString("Status")).getChunkType() : ChunkStatus.ChunkType.PROTOCHUNK;
ChunkStatus chunkstatus = ChunkStatus.byName(nbt.getCompound("Level").getString("Status")); }
diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java --- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
@@ -174,7 +138,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable { @@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable {
public final java.util.concurrent.locks.ReentrantLock fileLock = new java.util.concurrent.locks.ReentrantLock(true); // Paper public final java.util.concurrent.locks.ReentrantLock fileLock = new java.util.concurrent.locks.ReentrantLock(true); // Paper
public final File regionFile; // Paper public final Path regionFile; // Paper
+ // Paper start - Cache chunk status + // Paper start - Cache chunk status
+ private final ChunkStatus[] statuses = new ChunkStatus[32 * 32]; + private final ChunkStatus[] statuses = new ChunkStatus[32 * 32];
@@ -200,8 +164,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ } + }
+ // Paper end + // Paper end
+ +
public RegionFile(File file, File directory, boolean dsync) throws IOException { public RegionFile(Path path, Path path1, boolean dsync) throws IOException {
this(file.toPath(), directory.toPath(), RegionFileVersion.VERSION_DEFLATE, dsync); this(path, path1, RegionFileVersion.VERSION_DEFLATE, dsync);
} }
@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable { @@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable {
return this.getOffset(pos) != 0; return this.getOffset(pos) != 0;
@@ -299,7 +263,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
- return true; - return true;
+ net.minecraft.world.level.chunk.storage.RegionFile file; + net.minecraft.world.level.chunk.storage.RegionFile file;
+ try { + try {
+ file = world.getChunkSource().chunkMap.regionFileCache.getFile(chunkPos, false); + file = world.getChunkSource().chunkMap.regionFileCache.getRegionFile(chunkPos, false);
+ } catch (IOException ex) { + } catch (IOException ex) {
+ throw new RuntimeException(ex); + throw new RuntimeException(ex);
+ } + }