couple more patches

patches/server/Always-parse-protochunk-light-sources-unless-it-is-m.patch

@@ -12,15 +12,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/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 {
-                 protochunk.setLightEngine(lightengine);
+             BelowZeroRetrogen belowzeroretrogen = protochunk.getBelowZeroRetrogen();
-             }
+             boolean flag2 = chunkstatus.isOrAfter(ChunkStatus.LIGHT) || belowzeroretrogen != null && belowzeroretrogen.targetStatus().isOrAfter(ChunkStatus.LIGHT);
  
--            if (!flag && protochunk.getStatus().isOrAfter(ChunkStatus.LIGHT)) {
+-            if (!flag && flag2) {
--                Iterator iterator = BlockPos.betweenClosed(pos.getMinBlockX(), world.getMinBuildHeight(), pos.getMinBlockZ(), pos.getMaxBlockX(), world.getMaxBuildHeight() - 1, pos.getMaxBlockZ()).iterator();
+-                Iterator iterator = BlockPos.betweenClosed(chunkPos.getMinBlockX(), world.getMinBuildHeight(), chunkPos.getMinBlockZ(), chunkPos.getMaxBlockX(), world.getMaxBuildHeight() - 1, chunkPos.getMaxBlockZ()).iterator();
 +            if (!flag) { // Paper - fix incorrect parsing of blocks that emit light - it should always parse it, unless the chunk is marked as lit
 +                // Paper start - let's make sure the implementation isn't as slow as possible
-+                int offX = pos.x << 4;
++                int offX = chunkPos.x << 4;
-+                int offZ = pos.z << 4;
++                int offZ = chunkPos.z << 4;
 +
 +                int minChunkSection = io.papermc.paper.util.WorldUtil.getMinSection(world);
 +                int maxChunkSection = io.papermc.paper.util.WorldUtil.getMaxSection(world);
@@ -28,7 +28,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                LevelChunkSection[] sections = achunksection;
 +                for (int sectionY = minChunkSection; sectionY <= maxChunkSection; ++sectionY) {
 +                    LevelChunkSection section = sections[sectionY - minChunkSection];
-+                    if (section == null || section.isEmpty()) {
++                    if (section == null || section.hasOnlyAir()) {
 +                        // no sources in empty sections
 +                        continue;
 +                    }

patches/server/Prevent-unload-calls-removing-tickets-for-sync-loads.patch

@@ -0,0 +1,67 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <spottedleaf@spottedleaf.dev>
+Date: Thu, 18 Jun 2020 18:23:20 -0700
+Subject: [PATCH] Prevent unload() calls removing tickets for sync loads
+
+
+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 {
+         return completablefuture;
+     }
+ 
++    private long syncLoadCounter; // Paper - prevent plugin unloads from removing our ticket
++
+     private CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>> getChunkFutureMainThread(int chunkX, int chunkZ, ChunkStatus leastStatus, boolean create) {
+         // Paper start - add isUrgent - old sig left in place for dirty nms plugins
+         return getChunkFutureMainThread(chunkX, chunkZ, leastStatus, create, false);
+@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
+             ChunkHolder.FullChunkStatus currentChunkState = ChunkHolder.getFullChunkStatus(playerchunk.getTicketLevel());
+             currentlyUnloading = (oldChunkState.isOrAfter(ChunkHolder.FullChunkStatus.BORDER) && !currentChunkState.isOrAfter(ChunkHolder.FullChunkStatus.BORDER));
+         }
++        final Long identifier; // Paper - prevent plugin unloads from removing our ticket
+         if (create && !currentlyUnloading) {
+             // CraftBukkit end
+             this.distanceManager.addTicket(TicketType.UNKNOWN, chunkcoordintpair, l, chunkcoordintpair);
++            identifier = Long.valueOf(this.syncLoadCounter++); // Paper - prevent plugin unloads from removing our ticket
++            this.distanceManager.addTicketAtLevel(TicketType.REQUIRED_LOAD, chunkcoordintpair, l, identifier); // Paper - prevent plugin unloads from removing our ticket
+             if (isUrgent) this.distanceManager.markUrgent(chunkcoordintpair); // Paper - Chunk priority
+             if (this.chunkAbsent(playerchunk, l)) {
+                 ProfilerFiller gameprofilerfiller = this.level.getProfiler();
+@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
+                 playerchunk = this.getVisibleChunkIfPresent(k);
+                 gameprofilerfiller.pop();
+                 if (this.chunkAbsent(playerchunk, l)) {
++                    this.distanceManager.removeTicketAtLevel(TicketType.REQUIRED_LOAD, chunkcoordintpair, l, identifier); // Paper
+                     throw (IllegalStateException) Util.pauseInIde(new IllegalStateException("No chunk holder after ticket has been added"));
+                 }
+             }
+-        }
+ 
++        } else { identifier = null; } // Paper - prevent plugin unloads from removing our ticket
+         // Paper start - Chunk priority
+         CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>> future = this.chunkAbsent(playerchunk, l) ? ChunkHolder.UNLOADED_CHUNK_FUTURE : playerchunk.getOrScheduleFuture(leastStatus, this.chunkMap);
++        // Paper start - prevent plugin unloads from removing our ticket
++        if (create && !currentlyUnloading) {
++            future.thenAcceptAsync((either) -> {
++                ServerChunkCache.this.distanceManager.removeTicketAtLevel(TicketType.REQUIRED_LOAD, chunkcoordintpair, l, identifier);
++            }, ServerChunkCache.this.mainThreadProcessor);
++        }
++        // Paper end - prevent plugin unloads from removing our ticket
+         if (isUrgent) {
+             future.thenAccept(either -> this.distanceManager.clearUrgent(chunkcoordintpair));
+         }
+diff --git a/src/main/java/net/minecraft/server/level/TicketType.java b/src/main/java/net/minecraft/server/level/TicketType.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/server/level/TicketType.java
++++ b/src/main/java/net/minecraft/server/level/TicketType.java
+@@ -0,0 +0,0 @@ public class TicketType<T> {
+     public static final TicketType<Unit> PLUGIN = TicketType.create("plugin", (a, b) -> 0); // CraftBukkit
+     public static final TicketType<org.bukkit.plugin.Plugin> PLUGIN_TICKET = TicketType.create("plugin_ticket", (plugin1, plugin2) -> plugin1.getClass().getName().compareTo(plugin2.getClass().getName())); // CraftBukkit
+     public static final TicketType<Long> DELAY_UNLOAD = create("delay_unload", Long::compareTo, 300); // Paper
++    public static final TicketType<Long> REQUIRED_LOAD = create("required_load", Long::compareTo); // Paper - make sure getChunkAt does not fail
+ 
+     public static <T> TicketType<T> create(String name, Comparator<T> argumentComparator) {
+         return new TicketType<>(name, argumentComparator, 0L);

patches/server/Rewrite-the-light-engine.patch

@@ -4750,9 +4750,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/level/TicketType.java
 +++ b/src/main/java/net/minecraft/server/level/TicketType.java
 @@ -0,0 +0,0 @@ public class TicketType<T> {
-     public static final TicketType<Unit> PLUGIN = TicketType.create("plugin", (a, b) -> 0); // CraftBukkit
      public static final TicketType<org.bukkit.plugin.Plugin> PLUGIN_TICKET = TicketType.create("plugin_ticket", (plugin1, plugin2) -> plugin1.getClass().getName().compareTo(plugin2.getClass().getName())); // CraftBukkit
      public static final TicketType<Long> DELAY_UNLOAD = create("delay_unload", Long::compareTo, 300); // Paper
+     public static final TicketType<Long> REQUIRED_LOAD = create("required_load", Long::compareTo); // Paper - make sure getChunkAt does not fail
 +    public static final TicketType<Long> CHUNK_RELIGHT = create("light_update", Long::compareTo); // Paper - ensure chunks stay loaded for lighting
  
      public static <T> TicketType<T> create(String name, Comparator<T> argumentComparator) {