PaperMC/nms-patches/ChunkProviderServer.patch

--- a/net/minecraft/server/ChunkProviderServer.java
+++ b/net/minecraft/server/ChunkProviderServer.java
@@ -14,10 +14,16 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
+// CraftBukkit start
+import org.bukkit.Server;
+import org.bukkit.craftbukkit.chunkio.ChunkIOExecutor;
+import org.bukkit.event.world.ChunkUnloadEvent;
+// CraftBukkit end
+
 public class ChunkProviderServer implements IChunkProvider {
 
     private static final Logger a = LogManager.getLogger();
-    private final Set<Long> unloadQueue = Sets.newHashSet();
+    public final Set<Long> unloadQueue = Sets.newHashSet(); // PAIL: private -> public
     public final ChunkGenerator chunkGenerator;
     private final IChunkLoader chunkLoader;
     public final Long2ObjectMap<Chunk> chunks = new Long2ObjectOpenHashMap(8192);
@@ -69,19 +75,68 @@
         Chunk chunk = this.getLoadedChunkAt(i, j);
 
         if (chunk == null) {
-            chunk = this.loadChunk(i, j);
+            // CraftBukkit start
+            ChunkRegionLoader loader = null;
+
+            if (this.chunkLoader instanceof ChunkRegionLoader) {
+                loader = (ChunkRegionLoader) this.chunkLoader;
+            }
+            if (loader != null && loader.chunkExists(world, i, j)) {
+                chunk = ChunkIOExecutor.syncChunkLoad(world, loader, this, i, j);
+            }
+            /* chunk = this.loadChunk(i, j);
             if (chunk != null) {
                 this.chunks.put(ChunkCoordIntPair.a(i, j), chunk);
                 chunk.addEntities();
                 chunk.loadNearby(this, this.chunkGenerator);
             }
+            */
+            // CraftBukkit end
         }
 
         return chunk;
     }
 
     public Chunk getChunkAt(int i, int j) {
+        return getChunkAt(i, j, null);
+    }
+
+    public Chunk getChunkAt(int i, int j, Runnable runnable) {
+        return getChunkAt(i, j, runnable, true);
+    }
+
+    public Chunk getChunkAt(int i, int j, Runnable runnable, boolean generate) {
+        Chunk chunk = chunks.get(ChunkCoordIntPair.a(i, j));
+        ChunkRegionLoader loader = null;
+
+        if (this.chunkLoader instanceof ChunkRegionLoader) {
+            loader = (ChunkRegionLoader) this.chunkLoader;
+
+        }
+        // We can only use the queue for already generated chunks
+        if (chunk == null && loader != null && loader.chunkExists(world, i, j)) {
+            if (runnable != null) {
+                ChunkIOExecutor.queueChunkLoad(world, loader, this, i, j, runnable);
+                return null;
+            } else {
+                chunk = ChunkIOExecutor.syncChunkLoad(world, loader, this, i, j);
+            }
+        } else if (chunk == null && generate) {
+            chunk = originalGetChunkAt(i, j);
+        }
+
+        // If we didn't load the chunk async and have a callback run it now
+        if (runnable != null) {
+            runnable.run();
+        }
+
+        return chunk;
+    }
+
+    public Chunk originalGetChunkAt(int i, int j) {
         Chunk chunk = this.getOrLoadChunkAt(i, j);
+        boolean newChunk = false;
+        // CraftBukkit end
 
         if (chunk == null) {
             long k = ChunkCoordIntPair.a(i, j);
@@ -97,9 +152,37 @@
                 crashreportsystemdetails.a("Generator", (Object) this.chunkGenerator);
                 throw new ReportedException(crashreport);
             }
+            newChunk = true; // CraftBukkit
 
             this.chunks.put(k, chunk);
             chunk.addEntities();
+
+            // CraftBukkit start
+            Server server = world.getServer();
+            if (server != null) {
+                /*
+                 * If it's a new world, the first few chunks are generated inside
+                 * the World constructor. We can't reliably alter that, so we have
+                 * no way of creating a CraftWorld/CraftServer at that point.
+                 */
+                server.getPluginManager().callEvent(new org.bukkit.event.world.ChunkLoadEvent(chunk.bukkitChunk, newChunk));
+            }
+
+            // Update neighbor counts
+            for (int x = -2; x < 3; x++) {
+                for (int z = -2; z < 3; z++) {
+                    if (x == 0 && z == 0) {
+                        continue;
+                    }
+
+                    Chunk neighbor = this.getLoadedChunkAt(chunk.locX + x, chunk.locZ + z);
+                    if (neighbor != null) {
+                        neighbor.setNeighborLoaded(-x, -z);
+                        chunk.setNeighborLoaded(x, z);
+                    }
+                }
+            }
+            // CraftBukkit end
             chunk.loadNearby(this, this.chunkGenerator);
         }
 
@@ -146,10 +229,12 @@
 
     public boolean a(boolean flag) {
         int i = 0;
-        ArrayList arraylist = Lists.newArrayList(this.chunks.values());
 
-        for (int j = 0; j < arraylist.size(); ++j) {
-            Chunk chunk = (Chunk) arraylist.get(j);
+        // CraftBukkit start
+        Iterator iterator = this.chunks.values().iterator();
+        while (iterator.hasNext()) {
+            Chunk chunk = (Chunk) iterator.next();
+            // CraftBukkit end
 
             if (flag) {
                 this.saveChunkNOP(chunk);
@@ -182,6 +267,29 @@
                     Chunk chunk = (Chunk) this.chunks.get(olong);
 
                     if (chunk != null && chunk.d) {
+                        // CraftBukkit start
+                        ChunkUnloadEvent event = new ChunkUnloadEvent(chunk.bukkitChunk);
+                        this.world.getServer().getPluginManager().callEvent(event);
+                        if (event.isCancelled()) {
+                            continue;
+                        }
+
+                        // Update neighbor counts
+                        for (int x = -2; x < 3; x++) {
+                            for (int z = -2; z < 3; z++) {
+                                if (x == 0 && z == 0) {
+                                    continue;
+                                }
+
+                                Chunk neighbor = this.chunks.get(ChunkCoordIntPair.a(chunk.locX + x, chunk.locZ + z));
+                                if (neighbor != null) {
+                                    neighbor.setNeighborUnloaded(-x, -z);
+                                    chunk.setNeighborUnloaded(x, z);
+                                }
+                            }
+                        }
+                        // CraftBukkit end
+
                         chunk.removeEntities();
                         this.saveChunk(chunk);
                         this.saveChunkNOP(chunk);