Paper/src/main/java/net/minecraft/server/ChunkProviderServer.java

333 Zeilen
12 KiB
Java

2011-01-04 16:54:41 +01:00
package net.minecraft.server;
import java.io.IOException;
2011-01-29 22:50:29 +01:00
import java.util.ArrayList;
import java.util.HashSet;
2012-01-12 23:10:13 +01:00
import java.util.Iterator;
2011-01-29 22:50:29 +01:00
import java.util.List;
import java.util.Set;
// CraftBukkit start
2011-06-12 00:02:58 +02:00
import java.util.Random;
import org.bukkit.Server;
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
2011-01-04 16:54:41 +01:00
2011-02-20 17:40:40 +01:00
public class ChunkProviderServer implements IChunkProvider {
2011-03-31 22:40:00 +02:00
// CraftBukkit start
public LongHashSet unloadQueue = new LongHashSet();
public Chunk emptyChunk;
public IChunkProvider chunkProvider; // CraftBukkit
2011-05-26 14:48:22 +02:00
private IChunkLoader e;
public boolean forceChunkLoad = false; // true -> false
public LongObjectHashMap<Chunk> chunks = new LongObjectHashMap<Chunk>();
public WorldServer world;
2011-03-31 22:40:00 +02:00
// CraftBukkit end
2011-01-04 16:54:41 +01:00
public ChunkProviderServer(WorldServer worldserver, IChunkLoader ichunkloader, IChunkProvider ichunkprovider) {
2012-03-01 11:49:23 +01:00
this.emptyChunk = new EmptyChunk(worldserver, 0, 0);
this.world = worldserver;
2011-05-26 14:48:22 +02:00
this.e = ichunkloader;
this.chunkProvider = ichunkprovider;
2011-01-04 16:54:41 +01:00
}
public boolean isChunkLoaded(int i, int j) {
return this.chunks.containsKey(LongHash.toLong(i, j)); // CraftBukkit
2011-01-04 16:54:41 +01:00
}
public void queueUnload(int i, int j) {
2012-07-29 09:33:13 +02:00
if (this.world.worldProvider.e()) {
2011-11-20 09:01:14 +01:00
ChunkCoordinates chunkcoordinates = this.world.getSpawn();
int k = i * 16 + 8 - chunkcoordinates.x;
int l = j * 16 + 8 - chunkcoordinates.z;
short short1 = 128;
// CraftBukkit start
if (k < -short1 || k > short1 || l < -short1 || l > short1 || !(this.world.keepSpawnInMemory)) { // Added 'this.world.keepSpawnInMemory'
this.unloadQueue.add(i, j);
Chunk c = this.chunks.get(LongHash.toLong(i, j));
if (c != null) {
c.mustSave = true;
}
2011-11-20 09:01:14 +01:00
}
// CraftBukkit end
2011-11-20 09:01:14 +01:00
} else {
// CraftBukkit start
this.unloadQueue.add(i, j);
Chunk c = this.chunks.get(LongHash.toLong(i, j));
if (c != null) {
c.mustSave = true;
}
// CraftBukkit end
2011-01-04 16:54:41 +01:00
}
}
2012-07-29 09:33:13 +02:00
public void a() {
Iterator iterator = this.chunks.values().iterator(); // CraftBukkit
2012-01-12 23:10:13 +01:00
while (iterator.hasNext()) {
Chunk chunk = (Chunk) iterator.next();
this.queueUnload(chunk.x, chunk.z);
}
}
2013-03-25 05:22:32 +01:00
// CraftBukkit start - Add async variant, provide compatibility
public Chunk getChunkAt(int i, int j) {
Load chunks asynchronously for players. When a player triggers a chunk load via walking around or teleporting there is no need to stop everything and get this chunk on the main thread. The client is used to having to wait some time for this chunk and the server doesn't immediately do anything with it except send it to the player. At the same time chunk loading is the last major source of file IO that still runs on the main thread. These two facts make it possible to offload chunks loaded for this reason to another thread. However, not all parts of chunk loading can happen off the main thread. For this we use the new AsynchronousExecutor system to split chunk loading in to three pieces. The first is loading data from disk, decompressing it, and parsing it in to an NBT structure. The second piece is creating entities and tile entities in the chunk and adding them to the world, this is still done on the main thread. The third piece is informing everyone who requested a chunk load that the load is finished. For this we register callbacks and then run them on the main thread once the previous two stages are finished. There are still cases where a chunk is needed immediately and these will still trigger chunk loading entirely on the main thread. The most obvious case is plugins using the API to request a chunk load. We also must load the chunk immediately when something in the world tries to access it. In these cases we ignore any possibly pending or in progress chunk loading that is happening asynchronously as we will have the chunk loaded by the time they are finished. The hope is that overall this system will result in less CPU time and pauses due to blocking file IO on the main thread thus giving more consistent performance. Testing so far has shown that this also speeds up chunk loading client side although some of this is likely to be because we are sending less chunks at once for the client to process. Thanks for @ammaraskar for help with the implementation of this feature.
2012-11-30 09:49:19 +01:00
return getChunkAt(i, j, null);
}
public Chunk getChunkAt(int i, int j, Runnable runnable) {
this.unloadQueue.remove(i, j);
Chunk chunk = (Chunk) this.chunks.get(LongHash.toLong(i, j));
2011-06-16 20:33:36 +02:00
boolean newChunk = false;
Load chunks asynchronously for players. When a player triggers a chunk load via walking around or teleporting there is no need to stop everything and get this chunk on the main thread. The client is used to having to wait some time for this chunk and the server doesn't immediately do anything with it except send it to the player. At the same time chunk loading is the last major source of file IO that still runs on the main thread. These two facts make it possible to offload chunks loaded for this reason to another thread. However, not all parts of chunk loading can happen off the main thread. For this we use the new AsynchronousExecutor system to split chunk loading in to three pieces. The first is loading data from disk, decompressing it, and parsing it in to an NBT structure. The second piece is creating entities and tile entities in the chunk and adding them to the world, this is still done on the main thread. The third piece is informing everyone who requested a chunk load that the load is finished. For this we register callbacks and then run them on the main thread once the previous two stages are finished. There are still cases where a chunk is needed immediately and these will still trigger chunk loading entirely on the main thread. The most obvious case is plugins using the API to request a chunk load. We also must load the chunk immediately when something in the world tries to access it. In these cases we ignore any possibly pending or in progress chunk loading that is happening asynchronously as we will have the chunk loaded by the time they are finished. The hope is that overall this system will result in less CPU time and pauses due to blocking file IO on the main thread thus giving more consistent performance. Testing so far has shown that this also speeds up chunk loading client side although some of this is likely to be because we are sending less chunks at once for the client to process. Thanks for @ammaraskar for help with the implementation of this feature.
2012-11-30 09:49:19 +01:00
ChunkRegionLoader loader = null;
if (this.e instanceof ChunkRegionLoader) {
loader = (ChunkRegionLoader) this.e;
}
// If the chunk exists but isn't loaded do it async
if (chunk == null && runnable != null && loader != null && loader.chunkExists(this.world, i, j)) {
2013-03-25 05:22:32 +01:00
org.bukkit.craftbukkit.chunkio.ChunkIOExecutor.queueChunkLoad(this.world, loader, this, i, j, runnable);
Load chunks asynchronously for players. When a player triggers a chunk load via walking around or teleporting there is no need to stop everything and get this chunk on the main thread. The client is used to having to wait some time for this chunk and the server doesn't immediately do anything with it except send it to the player. At the same time chunk loading is the last major source of file IO that still runs on the main thread. These two facts make it possible to offload chunks loaded for this reason to another thread. However, not all parts of chunk loading can happen off the main thread. For this we use the new AsynchronousExecutor system to split chunk loading in to three pieces. The first is loading data from disk, decompressing it, and parsing it in to an NBT structure. The second piece is creating entities and tile entities in the chunk and adding them to the world, this is still done on the main thread. The third piece is informing everyone who requested a chunk load that the load is finished. For this we register callbacks and then run them on the main thread once the previous two stages are finished. There are still cases where a chunk is needed immediately and these will still trigger chunk loading entirely on the main thread. The most obvious case is plugins using the API to request a chunk load. We also must load the chunk immediately when something in the world tries to access it. In these cases we ignore any possibly pending or in progress chunk loading that is happening asynchronously as we will have the chunk loaded by the time they are finished. The hope is that overall this system will result in less CPU time and pauses due to blocking file IO on the main thread thus giving more consistent performance. Testing so far has shown that this also speeds up chunk loading client side although some of this is likely to be because we are sending less chunks at once for the client to process. Thanks for @ammaraskar for help with the implementation of this feature.
2012-11-30 09:49:19 +01:00
return null;
}
2011-02-07 09:43:51 +01:00
// CraftBukkit end
2011-01-04 16:54:41 +01:00
if (chunk == null) {
chunk = this.loadChunk(i, j);
2011-01-04 16:54:41 +01:00
if (chunk == null) {
if (this.chunkProvider == null) {
chunk = this.emptyChunk;
2011-01-04 16:54:41 +01:00
} else {
2012-11-06 13:05:28 +01:00
try {
chunk = this.chunkProvider.getOrCreateChunk(i, j);
} catch (Throwable throwable) {
CrashReport crashreport = CrashReport.a(throwable, "Exception generating new chunk");
CrashReportSystemDetails crashreportsystemdetails = crashreport.a("Chunk to be generated");
crashreportsystemdetails.a("Location", String.format("%d,%d", new Object[] { Integer.valueOf(i), Integer.valueOf(j)}));
2013-03-25 05:22:32 +01:00
crashreportsystemdetails.a("Position hash", Long.valueOf(LongHash.toLong(i, j))); // CraftBukkit - Use LongHash
2012-11-06 13:05:28 +01:00
crashreportsystemdetails.a("Generator", this.chunkProvider.getName());
throw new ReportedException(crashreport);
}
2011-01-04 16:54:41 +01:00
}
newChunk = true; // CraftBukkit
2011-01-04 16:54:41 +01:00
}
2011-01-29 22:50:29 +01:00
this.chunks.put(LongHash.toLong(i, j), chunk); // CraftBukkit
2011-01-04 16:54:41 +01:00
if (chunk != null) {
chunk.addEntities();
2011-01-04 16:54:41 +01:00
}
// CraftBukkit start
Server server = this.world.getServer();
2011-01-04 16:54:41 +01:00
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));
2011-01-04 16:54:41 +01:00
}
// CraftBukkit end
2011-01-04 16:54:41 +01:00
2011-09-15 02:23:52 +02:00
chunk.a(this, this, i, j);
2011-01-04 16:54:41 +01:00
}
2011-01-29 22:50:29 +01:00
Load chunks asynchronously for players. When a player triggers a chunk load via walking around or teleporting there is no need to stop everything and get this chunk on the main thread. The client is used to having to wait some time for this chunk and the server doesn't immediately do anything with it except send it to the player. At the same time chunk loading is the last major source of file IO that still runs on the main thread. These two facts make it possible to offload chunks loaded for this reason to another thread. However, not all parts of chunk loading can happen off the main thread. For this we use the new AsynchronousExecutor system to split chunk loading in to three pieces. The first is loading data from disk, decompressing it, and parsing it in to an NBT structure. The second piece is creating entities and tile entities in the chunk and adding them to the world, this is still done on the main thread. The third piece is informing everyone who requested a chunk load that the load is finished. For this we register callbacks and then run them on the main thread once the previous two stages are finished. There are still cases where a chunk is needed immediately and these will still trigger chunk loading entirely on the main thread. The most obvious case is plugins using the API to request a chunk load. We also must load the chunk immediately when something in the world tries to access it. In these cases we ignore any possibly pending or in progress chunk loading that is happening asynchronously as we will have the chunk loaded by the time they are finished. The hope is that overall this system will result in less CPU time and pauses due to blocking file IO on the main thread thus giving more consistent performance. Testing so far has shown that this also speeds up chunk loading client side although some of this is likely to be because we are sending less chunks at once for the client to process. Thanks for @ammaraskar for help with the implementation of this feature.
2012-11-30 09:49:19 +01:00
// CraftBukkit start - If we didn't need to load the chunk run the callback now
if (runnable != null) {
runnable.run();
}
// CraftBukkit end
2011-01-04 16:54:41 +01:00
return chunk;
}
public Chunk getOrCreateChunk(int i, int j) {
2011-03-31 22:40:00 +02:00
// CraftBukkit start
Chunk chunk = (Chunk) this.chunks.get(LongHash.toLong(i, j));
chunk = chunk == null ? (!this.world.isLoading && !this.forceChunkLoad ? this.emptyChunk : this.getChunkAt(i, j)) : chunk;
if (chunk == this.emptyChunk) return chunk;
if (i != chunk.x || j != chunk.z) {
2013-03-13 23:33:27 +01:00
this.world.getLogger().severe("Chunk (" + chunk.x + ", " + chunk.z + ") stored at (" + i + ", " + j + ") in world '" + world.getWorld().getName() + "'");
this.world.getLogger().severe(chunk.getClass().getName());
Throwable ex = new Throwable();
ex.fillInStackTrace();
ex.printStackTrace();
2011-02-24 09:51:00 +01:00
}
return chunk;
2011-03-31 22:40:00 +02:00
// CraftBukkit end
2011-01-04 16:54:41 +01:00
}
2011-05-14 16:29:42 +02:00
public Chunk loadChunk(int i, int j) { // CraftBukkit - private -> public
2011-05-26 14:48:22 +02:00
if (this.e == null) {
2011-01-04 16:54:41 +01:00
return null;
2011-01-29 22:50:29 +01:00
} else {
try {
2011-05-26 14:48:22 +02:00
Chunk chunk = this.e.a(this.world, i, j);
2011-01-04 16:54:41 +01:00
2011-01-29 22:50:29 +01:00
if (chunk != null) {
2012-03-01 11:49:23 +01:00
chunk.n = this.world.getTime();
if (this.chunkProvider != null) {
this.chunkProvider.recreateStructures(i, j);
}
2011-01-29 22:50:29 +01:00
}
return chunk;
} catch (Exception exception) {
exception.printStackTrace();
return null;
2011-01-04 16:54:41 +01:00
}
}
}
2011-05-14 16:29:42 +02:00
public void saveChunkNOP(Chunk chunk) { // CraftBukkit - private -> public
2011-05-26 14:48:22 +02:00
if (this.e != null) {
2011-01-29 22:50:29 +01:00
try {
2011-05-26 14:48:22 +02:00
this.e.b(this.world, chunk);
2011-01-29 22:50:29 +01:00
} catch (Exception exception) {
exception.printStackTrace();
}
2011-01-04 16:54:41 +01:00
}
}
2011-05-14 16:29:42 +02:00
public void saveChunk(Chunk chunk) { // CraftBukkit - private -> public
2011-05-26 14:48:22 +02:00
if (this.e != null) {
2011-01-29 22:50:29 +01:00
try {
2012-03-01 11:49:23 +01:00
chunk.n = this.world.getTime();
2011-05-26 14:48:22 +02:00
this.e.a(this.world, chunk);
2011-01-29 22:50:29 +01:00
} catch (Exception ioexception) { // CraftBukkit - IOException -> Exception
ioexception.printStackTrace();
2013-03-25 05:22:32 +01:00
// CraftBukkit start - Remove extra exception
2011-01-29 22:50:29 +01:00
}
2012-07-29 09:33:13 +02:00
// } catch (ExceptionWorldConflict exceptionworldconflict) {
// exceptionworldconflict.printStackTrace();
// }
// CraftBukkit end
2011-01-04 16:54:41 +01:00
}
}
public void getChunkAt(IChunkProvider ichunkprovider, int i, int j) {
Chunk chunk = this.getOrCreateChunk(i, j);
2011-01-04 16:54:41 +01:00
if (!chunk.done) {
chunk.done = true;
if (this.chunkProvider != null) {
this.chunkProvider.getChunkAt(ichunkprovider, i, j);
2011-06-12 00:02:58 +02:00
// CraftBukkit start
BlockSand.instaFall = true;
Random random = new Random();
random.setSeed(world.getSeed());
long xRand = random.nextLong() / 2L * 2L + 1L;
long zRand = random.nextLong() / 2L * 2L + 1L;
random.setSeed((long) i * xRand + (long) j * zRand ^ world.getSeed());
org.bukkit.World world = this.world.getWorld();
if (world != null) {
for (org.bukkit.generator.BlockPopulator populator : world.getPopulators()) {
populator.populate(world, random, chunk.bukkitChunk);
}
}
BlockSand.instaFall = false;
this.world.getServer().getPluginManager().callEvent(new org.bukkit.event.world.ChunkPopulateEvent(chunk.bukkitChunk));
2011-06-12 00:02:58 +02:00
// CraftBukkit end
2012-03-01 11:49:23 +01:00
chunk.e();
2011-01-04 16:54:41 +01:00
}
}
}
public boolean saveChunks(boolean flag, IProgressUpdate iprogressupdate) {
2011-01-04 16:54:41 +01:00
int i = 0;
2012-11-06 13:05:28 +01:00
// CraftBukkit start
Iterator iterator = this.chunks.values().iterator();
2011-01-04 16:54:41 +01:00
2012-07-29 09:33:13 +02:00
while (iterator.hasNext()) {
Chunk chunk = (Chunk) iterator.next();
2012-11-06 13:05:28 +01:00
// CraftBukkit end
2011-01-04 16:54:41 +01:00
2012-03-01 11:49:23 +01:00
if (flag) {
this.saveChunkNOP(chunk);
2011-01-04 16:54:41 +01:00
}
2011-01-29 22:50:29 +01:00
if (chunk.a(flag)) {
this.saveChunk(chunk);
2012-03-01 11:49:23 +01:00
chunk.l = false;
2011-01-29 22:50:29 +01:00
++i;
if (i == 24 && !flag) {
return false;
}
2011-01-04 16:54:41 +01:00
}
}
2013-04-27 11:40:05 +02:00
return true;
}
2011-01-29 22:50:29 +01:00
2013-04-27 11:40:05 +02:00
public void b() {
if (this.e != null) {
2011-05-26 14:48:22 +02:00
this.e.b();
2011-01-04 16:54:41 +01:00
}
}
public boolean unloadChunks() {
if (!this.world.savingDisabled) {
// 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);
2011-02-20 17:40:40 +01:00
if (chunk == null) continue;
ChunkUnloadEvent event = new ChunkUnloadEvent(chunk.bukkitChunk);
2011-02-23 13:56:36 +01:00
server.getPluginManager().callEvent(event);
if (!event.isCancelled()) {
chunk.removeEntities();
this.saveChunk(chunk);
this.saveChunkNOP(chunk);
2011-05-14 16:29:42 +02:00
// this.unloadQueue.remove(integer);
this.chunks.remove(chunkcoordinates); // CraftBukkit
}
2011-01-04 16:54:41 +01:00
}
// CraftBukkit end
2011-01-04 16:54:41 +01:00
2011-05-26 14:48:22 +02:00
if (this.e != null) {
this.e.a();
2011-01-04 16:54:41 +01:00
}
}
2011-01-29 22:50:29 +01:00
return this.chunkProvider.unloadChunks();
2011-01-04 16:54:41 +01:00
}
public boolean canSave() {
return !this.world.savingDisabled;
2011-01-04 16:54:41 +01:00
}
2011-11-20 09:01:14 +01:00
2012-07-29 09:33:13 +02:00
public String getName() {
2012-03-01 11:49:23 +01:00
return "ServerChunkCache: " + this.chunks.values().size() + " Drop: " + this.unloadQueue.size(); // CraftBukkit
2012-01-12 23:10:13 +01:00
}
2012-01-12 16:27:39 +01:00
public List getMobsFor(EnumCreatureType enumcreaturetype, int i, int j, int k) {
return this.chunkProvider.getMobsFor(enumcreaturetype, i, j, k);
2011-11-20 09:01:14 +01:00
}
2012-01-12 16:27:39 +01:00
public ChunkPosition findNearestMapFeature(World world, String s, int i, int j, int k) {
return this.chunkProvider.findNearestMapFeature(world, s, i, j, k);
2011-11-20 09:01:14 +01:00
}
2012-07-29 09:33:13 +02:00
public int getLoadedChunks() {
return this.chunks.values().size(); // CraftBukkit
}
public void recreateStructures(int i, int j) {}
2011-01-04 16:54:41 +01:00
}