PaperMC/nms-patches/ChunkProviderServer.patch

--- a/net/minecraft/server/ChunkProviderServer.java
+++ b/net/minecraft/server/ChunkProviderServer.java
@@ -1,24 +1,31 @@
 package net.minecraft.server;
 
-import com.google.common.collect.Lists;
 import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
+
 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.craftbukkit.util.LongHash;
+import org.bukkit.craftbukkit.util.LongHashSet;
+import org.bukkit.craftbukkit.util.LongObjectHashMap;
+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 = Collections.newSetFromMap(new ConcurrentHashMap());
-    private final ChunkGenerator chunkGenerator;
+    public final LongHashSet unloadQueue = new LongHashSet(); // CraftBukkit - LongHashSet
+    public final ChunkGenerator chunkGenerator; // CraftBukkit - public
     private final IChunkLoader chunkLoader;
-    private final LongHashMap<Chunk> chunks = new LongHashMap();
-    private final List<Chunk> chunkList = Lists.newArrayList();
+    public LongObjectHashMap<Chunk> chunks = new LongObjectHashMap<Chunk>(); // CraftBukkit
+    // private final LongHashMap<Chunk> chunks = new LongHashMap();
+    // private final List<Chunk> chunkList = Lists.newArrayList();
     public final WorldServer world;
 
     public ChunkProviderServer(WorldServer worldserver, IChunkLoader ichunkloader, ChunkGenerator chunkgenerator) {
@@ -27,19 +34,33 @@
         this.chunkGenerator = chunkgenerator;
     }
 
-    public List<Chunk> a() {
-        return this.chunkList;
+    public boolean isChunkLoaded(int i, int j) {
+        return this.chunks.containsKey(LongHash.toLong(i, j)); // CraftBukkit
+    }
+
+    // CraftBukkit start - Change return type to Collection and return the values of our chunk map
+    public java.util.Collection a() {
+        // return this.chunkList;
+        return this.chunks.values();
+        // CraftBukkit end
     }
 
     public void queueUnload(int i, int j) {
         if (this.world.worldProvider.c(i, j)) {
-            this.unloadQueue.add(Long.valueOf(ChunkCoordIntPair.a(i, j)));
+            // CraftBukkit start
+            this.unloadQueue.add(i, j);
+
+            Chunk c = chunks.get(LongHash.toLong(i, j));
+            if (c != null) {
+                c.mustSave = true;
+            }
+            // CraftBukkit end
         }
 
     }
 
     public void b() {
-        Iterator iterator = this.chunkList.iterator();
+        Iterator iterator = this.chunks.values().iterator(); // CraftBukkit
 
         while (iterator.hasNext()) {
             Chunk chunk = (Chunk) iterator.next();
@@ -49,11 +70,20 @@
 
     }
 
+    // CraftBukkit start - Add async variant, provide compatibility
+    public Chunk getOrCreateChunkFast(int x, int z) {
+        Chunk chunk = chunks.get(LongHash.toLong(x, z));
+        return (chunk == null) ? getChunkAt(x, z) : chunk;
+    }
+
+    public Chunk getChunkIfLoaded(int x, int z) {
+        return chunks.get(LongHash.toLong(x, z));
+    }
+
     public Chunk getLoadedChunkAt(int i, int j) {
-        long k = ChunkCoordIntPair.a(i, j);
-        Chunk chunk = (Chunk) this.chunks.getEntry(k);
+        Chunk chunk = chunks.get(LongHash.toLong(i, j)); // CraftBukkit
 
-        this.unloadQueue.remove(Long.valueOf(k));
+        this.unloadQueue.remove(i, j); // CraftBukkit
         return chunk;
     }
 
@@ -61,20 +91,67 @@
         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);
                 this.chunkList.add(chunk);
                 chunk.addEntities();
                 chunk.loadNearby(this, this.chunkGenerator);
             }
+            */
+            // CraftBukkit end
         }
 
         return chunk;
     }
 
     public Chunk getChunkAt(int i, int j) {
-        Chunk chunk = this.getOrLoadChunkAt(i, j);
+        return getChunkAt(i, j, null);
+    }
+
+    public Chunk getChunkAt(int i, int j, Runnable runnable) {
+        unloadQueue.remove(i, j);
+        Chunk chunk = chunks.get(LongHash.toLong(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) {
+            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) {
+        this.unloadQueue.remove(i, j);
+        Chunk chunk = this.chunks.get(LongHash.toLong(i, j));
+        boolean newChunk = false;
+        // CraftBukkit end
 
         if (chunk == null) {
             long k = ChunkCoordIntPair.a(i, j);
@@ -92,11 +169,38 @@
                     crashreportsystemdetails.a("Generator", (Object) this.chunkGenerator);
                     throw new ReportedException(crashreport);
                 }
+                newChunk = true; // CraftBukkit
             }
 
-            this.chunks.put(k, chunk);
-            this.chunkList.add(chunk);
+            this.chunks.put(LongHash.toLong(i, j), chunk); // CraftBukkit
             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.getChunkIfLoaded(chunk.locX + x, chunk.locZ + z);
+                    if (neighbor != null) {
+                        neighbor.setNeighborLoaded(-x, -z);
+                        chunk.setNeighborLoaded(x, z);
+                    }
+                }
+            }
+            // CraftBukkit end
             chunk.loadNearby(this, this.chunkGenerator);
         }
 
@@ -142,10 +246,12 @@
 
     public boolean a(boolean flag) {
         int i = 0;
-        ArrayList arraylist = Lists.newArrayList(this.chunkList);
 
-        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);
@@ -170,22 +276,43 @@
 
     public boolean unloadChunks() {
         if (!this.world.savingDisabled) {
-            for (int i = 0; i < 100; ++i) {
-                if (!this.unloadQueue.isEmpty()) {
-                    Long olong = (Long) this.unloadQueue.iterator().next();
-                    Chunk chunk = (Chunk) this.chunks.getEntry(olong.longValue());
+            // CraftBukkit start
+            Server server = this.world.getServer();
+            for (int i = 0; i < 100 && !this.unloadQueue.isEmpty(); ++i) {
+                long chunkcoordinates = this.unloadQueue.popFirst();
+                Chunk chunk = this.chunks.get(chunkcoordinates);
+                if (chunk == null) continue;
+
+                ChunkUnloadEvent event = new ChunkUnloadEvent(chunk.bukkitChunk);
+                server.getPluginManager().callEvent(event);
+                if (!event.isCancelled()) {
 
                     if (chunk != null) {
                         chunk.removeEntities();
                         this.saveChunk(chunk);
                         this.saveChunkNOP(chunk);
-                        this.chunks.remove(olong.longValue());
-                        this.chunkList.remove(chunk);
+                        this.chunks.remove(chunkcoordinates); // CraftBukkit
                     }
 
-                    this.unloadQueue.remove(olong);
+                    // this.unloadQueue.remove(olong);
+
+                    // 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.getChunkIfLoaded(chunk.locX + x, chunk.locZ + z);
+                            if (neighbor != null) {
+                                neighbor.setNeighborUnloaded(-x, -z);
+                                chunk.setNeighborUnloaded(x, z);
+                            }
+                        }
+                    }
                 }
             }
+            // CraftBukkit end
 
             this.chunkLoader.a();
         }
@@ -198,7 +325,8 @@
     }
 
     public String getName() {
-        return "ServerChunkCache: " + this.chunks.count() + " Drop: " + this.unloadQueue.size();
+        // CraftBukkit - this.chunks.count() -> .size()
+        return "ServerChunkCache: " + this.chunks.size() + " Drop: " + this.unloadQueue.size();
     }
 
     public List<BiomeBase.BiomeMeta> a(EnumCreatureType enumcreaturetype, BlockPosition blockposition) {
@@ -210,10 +338,11 @@
     }
 
     public int g() {
-        return this.chunks.count();
+        // CraftBukkit - this.chunks.count() -> this.chunks.size()
+        return this.chunks.size();
     }
 
     public boolean e(int i, int j) {
-        return this.chunks.contains(ChunkCoordIntPair.a(i, j));
+        return this.chunks.containsKey(LongHash.toLong(i, j)); // CraftBukkit
     }
 }