void rethrow(final Throwable throwable) throws T {
+ throw (T)throwable;
+ }
+
+}
diff --git a/src/main/java/com/destroystokyo/paper/io/PaperFileIOThread.java b/src/main/java/com/destroystokyo/paper/io/PaperFileIOThread.java
new file mode 100644
index 000000000..4f10a8311
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/io/PaperFileIOThread.java
@@ -0,0 +1,661 @@
+package com.destroystokyo.paper.io;
+
+import net.minecraft.server.ChunkCoordIntPair;
+import net.minecraft.server.ExceptionWorldConflict;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.NBTTagCompound;
+import net.minecraft.server.RegionFile;
+import net.minecraft.server.WorldServer;
+import org.apache.logging.log4j.Logger;
+
+import java.io.IOException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+/**
+ * Prioritized singleton thread responsible for all chunk IO that occurs in a minecraft server.
+ *
+ *
+ * Singleton access: {@link Holder#INSTANCE}
+ *
+ *
+ *
+ * All functions provided are MT-Safe, however certain ordering constraints are (but not enforced):
+ *
+ * Chunk saves may not occur for unloaded chunks.
+ *
+ *
+ * Tasks must be scheduled on the main thread.
+ *
+ *
+ *
+ * @see Holder#INSTANCE
+ * @see #scheduleSave(WorldServer, int, int, NBTTagCompound, NBTTagCompound, int)
+ * @see #loadChunkDataAsync(WorldServer, int, int, int, Consumer, boolean, boolean, boolean)
+ */
+public final class PaperFileIOThread extends QueueExecutorThread {
+
+ public static final Logger LOGGER = MinecraftServer.LOGGER;
+ public static final NBTTagCompound FAILURE_VALUE = new NBTTagCompound();
+
+ public static final class Holder {
+
+ public static final PaperFileIOThread INSTANCE = new PaperFileIOThread();
+
+ static {
+ INSTANCE.start();
+ }
+ }
+
+ private final AtomicLong writeCounter = new AtomicLong();
+
+ private PaperFileIOThread() {
+ super(new PrioritizedTaskQueue<>(), (int)(1.0e6)); // 1.0ms spinwait time
+ this.setName("Paper RegionFile IO Thread");
+ this.setPriority(Thread.NORM_PRIORITY - 1); // we keep priority close to normal because threads can wait on us
+ this.setUncaughtExceptionHandler((final Thread unused, final Throwable thr) -> {
+ LOGGER.fatal("Uncaught exception thrown from IO thread, report this!", thr);
+ });
+ }
+
+ /* run() is implemented by superclass */
+
+ /*
+ *
+ * IO thread will perform reads before writes
+ *
+ * How reads/writes are scheduled:
+ *
+ * If read in progress while scheduling write, ignore read and schedule write
+ * If read in progress while scheduling read (no write in progress), chain the read task
+ *
+ *
+ * If write in progress while scheduling read, use the pending write data and ret immediately
+ * If write in progress while scheduling write (ignore read in progress), overwrite the write in progress data
+ *
+ * This allows the reads and writes to act as if they occur synchronously to the thread scheduling them, however
+ * it fails to properly propagate write failures. When writes fail the data is kept so future reads will actually
+ * read the failed write data. This should hopefully act as a way to prevent data loss for spurious fails for writing data.
+ *
+ */
+
+ /**
+ * Attempts to bump the priority of all IO tasks for the given chunk coordinates. This has no effect if no tasks are queued.
+ * @param world Chunk's world
+ * @param chunkX Chunk's x coordinate
+ * @param chunkZ Chunk's z coordinate
+ * @param priority Priority level to try to bump to
+ */
+ public void bumpPriority(final WorldServer world, final int chunkX, final int chunkZ, final int priority) {
+ if (!PrioritizedTaskQueue.validPriority(priority)) {
+ throw new IllegalArgumentException("Invalid priority: " + priority);
+ }
+
+ final Long key = Long.valueOf(IOUtil.getCoordinateKey(chunkX, chunkZ));
+
+ final ChunkDataTask poiTask = world.poiDataController.tasks.get(key);
+ final ChunkDataTask chunkTask = world.chunkDataController.tasks.get(key);
+
+ if (poiTask != null) {
+ poiTask.raisePriority(priority);
+ }
+ if (chunkTask != null) {
+ chunkTask.raisePriority(priority);
+ }
+ }
+
+ // Hack start
+ /**
+ * if {@code waitForRead} is true, then this task will wait on an available read task, else it will wait on an available
+ * write task
+ * if {@code poiTask} is true, then this task will wait on a poi task, else it will wait on chunk data task
+ * @deprecated API is garbage and will only work for main thread queueing of tasks (which is vanilla), plugins messing
+ * around asynchronously will give unexpected results
+ * @return whether the task succeeded, or {@code null} if there is no task
+ */
+ @Deprecated
+ public Boolean waitForIOToComplete(final WorldServer world, final int chunkX, final int chunkZ, final boolean waitForRead,
+ final boolean poiTask) {
+ final ChunkDataTask task;
+
+ final Long key = IOUtil.getCoordinateKey(chunkX, chunkZ);
+ if (poiTask) {
+ task = world.poiDataController.tasks.get(key);
+ } else {
+ task = world.chunkDataController.tasks.get(key);
+ }
+
+ if (task == null) {
+ return null;
+ }
+
+ if (waitForRead) {
+ ChunkDataController.InProgressRead read = task.inProgressRead;
+ if (read == null) {
+ return null;
+ }
+ return Boolean.valueOf(read.readFuture.join() != PaperFileIOThread.FAILURE_VALUE);
+ }
+
+ // wait for write
+ ChunkDataController.InProgressWrite write = task.inProgressWrite;
+ if (write == null) {
+ return null;
+ }
+ return Boolean.valueOf(write.wrote.join() != PaperFileIOThread.FAILURE_VALUE);
+ }
+ // Hack end
+
+ public NBTTagCompound getPendingWrite(final WorldServer world, final int chunkX, final int chunkZ, final boolean poiData) {
+ final ChunkDataController taskController = poiData ? world.poiDataController : world.chunkDataController;
+
+ final ChunkDataTask dataTask = taskController.tasks.get(Long.valueOf(IOUtil.getCoordinateKey(chunkX, chunkZ)));
+
+ if (dataTask == null) {
+ return null;
+ }
+
+ final ChunkDataController.InProgressWrite write = dataTask.inProgressWrite;
+
+ if (write == null) {
+ return null;
+ }
+
+ return write.data;
+ }
+
+ /**
+ * Sets the priority of all IO tasks for the given chunk coordinates. This has no effect if no tasks are queued.
+ * @param world Chunk's world
+ * @param chunkX Chunk's x coordinate
+ * @param chunkZ Chunk's z coordinate
+ * @param priority Priority level to set to
+ */
+ public void setPriority(final WorldServer world, final int chunkX, final int chunkZ, final int priority) {
+ if (!PrioritizedTaskQueue.validPriority(priority)) {
+ throw new IllegalArgumentException("Invalid priority: " + priority);
+ }
+
+ final Long key = Long.valueOf(IOUtil.getCoordinateKey(chunkX, chunkZ));
+
+ final ChunkDataTask poiTask = world.poiDataController.tasks.get(key);
+ final ChunkDataTask chunkTask = world.chunkDataController.tasks.get(key);
+
+ if (poiTask != null) {
+ poiTask.updatePriority(priority);
+ }
+ if (chunkTask != null) {
+ chunkTask.updatePriority(priority);
+ }
+ }
+
+ /**
+ * Schedules the chunk data to be written asynchronously.
+ *
+ * Impl notes:
+ *
+ *
+ * This function presumes a chunk load for the coordinates is not called during this function (anytime after is OK). This means
+ * saves must be scheduled before a chunk is unloaded.
+ *
+ *
+ * Writes may be called concurrently, although only the "later" write will go through.
+ *
+ * @param world Chunk's world
+ * @param chunkX Chunk's x coordinate
+ * @param chunkZ Chunk's z coordinate
+ * @param poiData Chunk point of interest data. If {@code null}, then no poi data is saved.
+ * @param chunkData Chunk data. If {@code null}, then no chunk data is saved.
+ * @param priority Priority level for this task. See {@link PrioritizedTaskQueue}
+ * @throws IllegalArgumentException If both {@code poiData} and {@code chunkData} are {@code null}.
+ * @throws IllegalStateException If the file io thread has shutdown.
+ */
+ public void scheduleSave(final WorldServer world, final int chunkX, final int chunkZ,
+ final NBTTagCompound poiData, final NBTTagCompound chunkData,
+ final int priority) throws IllegalArgumentException {
+ if (!PrioritizedTaskQueue.validPriority(priority)) {
+ throw new IllegalArgumentException("Invalid priority: " + priority);
+ }
+
+ final long writeCounter = this.writeCounter.getAndIncrement();
+
+ if (poiData != null) {
+ this.scheduleWrite(world.poiDataController, world, chunkX, chunkZ, poiData, priority, writeCounter);
+ }
+ if (chunkData != null) {
+ this.scheduleWrite(world.chunkDataController, world, chunkX, chunkZ, chunkData, priority, writeCounter);
+ }
+ }
+
+ private void scheduleWrite(final ChunkDataController dataController, final WorldServer world,
+ final int chunkX, final int chunkZ, final NBTTagCompound data, final int priority, final long writeCounter) {
+ dataController.tasks.compute(Long.valueOf(IOUtil.getCoordinateKey(chunkX, chunkZ)), (final Long keyInMap, final ChunkDataTask taskRunning) -> {
+ if (taskRunning == null) {
+ // no task is scheduled
+
+ // create task
+ final ChunkDataTask newTask = new ChunkDataTask(priority, world, chunkX, chunkZ, dataController);
+ newTask.inProgressWrite = new ChunkDataController.InProgressWrite();
+ newTask.inProgressWrite.writeCounter = writeCounter;
+ newTask.inProgressWrite.data = data;
+
+ PaperFileIOThread.this.queueTask(newTask); // schedule
+ return newTask;
+ }
+
+ taskRunning.raisePriority(priority);
+
+ if (taskRunning.inProgressWrite == null) {
+ taskRunning.inProgressWrite = new ChunkDataController.InProgressWrite();
+ }
+
+ boolean reschedule = taskRunning.inProgressWrite.writeCounter == -1L;
+
+ // synchronize for readers
+ //noinspection SynchronizationOnLocalVariableOrMethodParameter
+ synchronized (taskRunning) {
+ taskRunning.inProgressWrite.data = data;
+ taskRunning.inProgressWrite.writeCounter = writeCounter;
+ }
+
+ if (reschedule) {
+ // We need to reschedule this task since the previous one is not currently scheduled since it failed
+ taskRunning.reschedule(priority);
+ }
+
+ return taskRunning;
+ });
+ }
+
+ /**
+ * Same as {@link #loadChunkDataAsync(WorldServer, int, int, int, Consumer, boolean, boolean, boolean)}, except this function returns
+ * a {@link CompletableFuture} which is potentially completed ASYNCHRONOUSLY ON THE FILE IO THREAD when the load task
+ * has completed.
+ *
+ * Note that if the chunk fails to load the returned future is completed with {@code null}.
+ *
+ */
+ public CompletableFuture loadChunkDataAsyncFuture(final WorldServer world, final int chunkX, final int chunkZ,
+ final int priority, final boolean readPoiData, final boolean readChunkData,
+ final boolean intendingToBlock) {
+ final CompletableFuture future = new CompletableFuture<>();
+ this.loadChunkDataAsync(world, chunkX, chunkZ, priority, future::complete, readPoiData, readChunkData, intendingToBlock);
+ return future;
+ }
+
+ /**
+ * Schedules a load to be executed asynchronously.
+ *
+ * Impl notes:
+ *
+ *
+ * If a chunk fails to load, the {@code onComplete} parameter is completed with {@code null}.
+ *
+ *
+ * It is possible for the {@code onComplete} parameter to be given {@link ChunkData} containing data
+ * this call did not request.
+ *
+ *
+ * The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
+ * be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
+ * data is undefined behaviour, and can cause deadlock.
+ *
+ * @param world Chunk's world
+ * @param chunkX Chunk's x coordinate
+ * @param chunkZ Chunk's z coordinate
+ * @param priority Priority level for this task. See {@link PrioritizedTaskQueue}
+ * @param onComplete Consumer to execute once this task has completed
+ * @param readPoiData Whether to read point of interest data. If {@code false}, the {@code NBTTagCompound} will be {@code null}.
+ * @param readChunkData Whether to read chunk data. If {@code false}, the {@code NBTTagCompound} will be {@code null}.
+ * @return The {@link PrioritizedTaskQueue.PrioritizedTask} associated with this task. Note that this task does not support
+ * cancellation.
+ */
+ public void loadChunkDataAsync(final WorldServer world, final int chunkX, final int chunkZ,
+ final int priority, final Consumer onComplete,
+ final boolean readPoiData, final boolean readChunkData,
+ final boolean intendingToBlock) {
+ if (!PrioritizedTaskQueue.validPriority(priority)) {
+ throw new IllegalArgumentException("Invalid priority: " + priority);
+ }
+
+ if (!(readPoiData | readChunkData)) {
+ throw new IllegalArgumentException("Must read chunk data or poi data");
+ }
+
+ final ChunkData complete = new ChunkData();
+ final boolean[] requireCompletion = new boolean[] { readPoiData, readChunkData };
+
+ if (readPoiData) {
+ this.scheduleRead(world.poiDataController, world, chunkX, chunkZ, (final NBTTagCompound poiData) -> {
+ complete.poiData = poiData;
+
+ final boolean finished;
+
+ // avoid a race condition where the file io thread completes and we complete synchronously
+ // Note: Synchronization can be elided if both of the accesses are volatile
+ synchronized (requireCompletion) {
+ requireCompletion[0] = false; // 0 -> poi data
+ finished = !requireCompletion[1]; // 1 -> chunk data
+ }
+
+ if (finished) {
+ onComplete.accept(complete);
+ }
+ }, priority, intendingToBlock);
+ }
+
+ if (readChunkData) {
+ this.scheduleRead(world.chunkDataController, world, chunkX, chunkZ, (final NBTTagCompound chunkData) -> {
+ complete.chunkData = chunkData;
+
+ final boolean finished;
+
+ // avoid a race condition where the file io thread completes and we complete synchronously
+ // Note: Synchronization can be elided if both of the accesses are volatile
+ synchronized (requireCompletion) {
+ requireCompletion[1] = false; // 1 -> chunk data
+ finished = !requireCompletion[0]; // 0 -> poi data
+ }
+
+ if (finished) {
+ onComplete.accept(complete);
+ }
+ }, priority, intendingToBlock);
+ }
+
+ }
+
+ // Note: the onComplete may be called asynchronously or synchronously here.
+ private void scheduleRead(final ChunkDataController dataController, final WorldServer world,
+ final int chunkX, final int chunkZ, final Consumer onComplete, final int priority,
+ final boolean intendingToBlock) {
+
+ Function tryLoadFunction = (final RegionFile file) -> {
+ if (file == null) {
+ return Boolean.TRUE;
+ }
+ return Boolean.valueOf(file.chunkExists(new ChunkCoordIntPair(chunkX, chunkZ)));
+ };
+
+ dataController.tasks.compute(Long.valueOf(IOUtil.getCoordinateKey(chunkX, chunkZ)), (final Long keyInMap, final ChunkDataTask running) -> {
+ if (running == null) {
+ // not scheduled
+
+ final Boolean shouldSchedule = intendingToBlock ? dataController.computeForRegionFile(chunkX, chunkZ, tryLoadFunction) :
+ dataController.computeForRegionFileIfLoaded(chunkX, chunkZ, tryLoadFunction);
+
+ if (shouldSchedule == Boolean.FALSE) {
+ // not on disk
+ onComplete.accept(null);
+ return null;
+ }
+
+ // set up task
+ final ChunkDataTask newTask = new ChunkDataTask(priority, world, chunkX, chunkZ, dataController);
+ newTask.inProgressRead = new ChunkDataController.InProgressRead();
+ newTask.inProgressRead.readFuture.thenAccept(onComplete);
+
+ PaperFileIOThread.this.queueTask(newTask); // schedule task
+ return newTask;
+ }
+
+ running.raisePriority(priority);
+
+ if (running.inProgressWrite == null) {
+ // chain to the read future
+ running.inProgressRead.readFuture.thenAccept(onComplete);
+ return running;
+ }
+
+ // at this stage we have to use the in progress write's data to avoid an order issue
+ // we don't synchronize since all writes to data occur in the compute() call
+ onComplete.accept(running.inProgressWrite.data);
+ return running;
+ });
+ }
+
+ /**
+ * Same as {@link #loadChunkDataAsync(WorldServer, int, int, int, Consumer, boolean, boolean, boolean)}, except this function returns
+ * the {@link ChunkData} associated with the specified chunk when the task is complete.
+ * @return The chunk data, or {@code null} if the chunk failed to load.
+ */
+ public ChunkData loadChunkData(final WorldServer world, final int chunkX, final int chunkZ, final int priority,
+ final boolean readPoiData, final boolean readChunkData) {
+ return this.loadChunkDataAsyncFuture(world, chunkX, chunkZ, priority, readPoiData, readChunkData, true).join();
+ }
+
+ /**
+ * Schedules the given task at the specified priority to be executed on the IO thread.
+ *
+ * Internal api. Do not use.
+ *
+ */
+ public void runTask(final int priority, final Runnable runnable) {
+ this.queueTask(new GeneralTask(priority, runnable));
+ }
+
+ static final class GeneralTask extends PrioritizedTaskQueue.PrioritizedTask implements Runnable {
+
+ private final Runnable run;
+
+ public GeneralTask(final int priority, final Runnable run) {
+ super(priority);
+ this.run = IOUtil.notNull(run, "Task may not be null");
+ }
+
+ @Override
+ public void run() {
+ try {
+ this.run.run();
+ } catch (final Throwable throwable) {
+ if (throwable instanceof ThreadDeath) {
+ throw (ThreadDeath)throwable;
+ }
+ LOGGER.fatal("Failed to execute general task on IO thread " + IOUtil.genericToString(this.run), throwable);
+ }
+ }
+ }
+
+ public static final class ChunkData {
+
+ public NBTTagCompound poiData;
+ public NBTTagCompound chunkData;
+
+ public ChunkData() {}
+
+ public ChunkData(final NBTTagCompound poiData, final NBTTagCompound chunkData) {
+ this.poiData = poiData;
+ this.chunkData = chunkData;
+ }
+ }
+
+ public static abstract class ChunkDataController {
+
+ // ConcurrentHashMap synchronizes per chain, so reduce the chance of task's hashes colliding.
+ public final ConcurrentHashMap tasks = new ConcurrentHashMap<>(64, 0.5f);
+
+ public abstract void writeData(final int x, final int z, final NBTTagCompound compound) throws IOException;
+ public abstract NBTTagCompound readData(final int x, final int z) throws IOException;
+
+ public abstract T computeForRegionFile(final int chunkX, final int chunkZ, final Function function);
+ public abstract T computeForRegionFileIfLoaded(final int chunkX, final int chunkZ, final Function function);
+
+ public static final class InProgressWrite {
+ public long writeCounter;
+ public NBTTagCompound data;
+
+ // Hack start
+ @Deprecated
+ public CompletableFuture wrote = new CompletableFuture<>();
+ // Hack end
+ }
+
+ public static final class InProgressRead {
+ public final CompletableFuture readFuture = new CompletableFuture<>();
+ }
+ }
+
+ public static final class ChunkDataTask extends PrioritizedTaskQueue.PrioritizedTask implements Runnable {
+
+ public ChunkDataController.InProgressWrite inProgressWrite;
+ public ChunkDataController.InProgressRead inProgressRead;
+
+ private final WorldServer world;
+ private final int x;
+ private final int z;
+ private final ChunkDataController taskController;
+
+ public ChunkDataTask(final int priority, final WorldServer world, final int x, final int z, final ChunkDataController taskController) {
+ super(priority);
+ this.world = world;
+ this.x = x;
+ this.z = z;
+ this.taskController = taskController;
+ }
+
+ @Override
+ public String toString() {
+ return "Task for world: '" + this.world.getWorld().getName() + "' at " + this.x + "," + this.z +
+ " poi: " + (this.taskController == this.world.poiDataController) + ", hash: " + this.hashCode();
+ }
+
+ /*
+ *
+ * IO thread will perform reads before writes
+ *
+ * How reads/writes are scheduled:
+ *
+ * If read in progress while scheduling write, ignore read and schedule write
+ * If read in progress while scheduling read (no write in progress), chain the read task
+ *
+ *
+ * If write in progress while scheduling read, use the pending write data and ret immediately
+ * If write in progress while scheduling write (ignore read in progress), overwrite the write in progress data
+ *
+ * This allows the reads and writes to act as if they occur synchronously to the thread scheduling them, however
+ * it fails to properly propagate write failures
+ *
+ */
+
+ void reschedule(final int priority) {
+ // priority is checked before this stage // TODO what
+ this.queue.lazySet(null);
+ this.inProgressWrite.wrote = new CompletableFuture<>(); // Hack
+ this.priority.lazySet(priority);
+ PaperFileIOThread.Holder.INSTANCE.queueTask(this);
+ }
+
+ @Override
+ public void run() {
+ ChunkDataController.InProgressRead read = this.inProgressRead;
+ if (read != null) {
+ NBTTagCompound compound = PaperFileIOThread.FAILURE_VALUE;
+ try {
+ compound = this.taskController.readData(this.x, this.z);
+ } catch (final Throwable thr) {
+ if (thr instanceof ThreadDeath) {
+ throw (ThreadDeath)thr;
+ }
+ LOGGER.fatal("Failed to read chunk data for task: " + this.toString(), thr);
+ // fall through to complete with null data
+ }
+ read.readFuture.complete(compound);
+ }
+
+ final Long chunkKey = Long.valueOf(IOUtil.getCoordinateKey(this.x, this.z));
+
+ ChunkDataController.InProgressWrite write = this.inProgressWrite;
+
+ if (write == null) {
+ // IntelliJ warns this is invalid, however it does not consider that writes to the task map & the inProgress field can occur concurrently.
+ ChunkDataTask inMap = this.taskController.tasks.compute(chunkKey, (final Long keyInMap, final ChunkDataTask valueInMap) -> {
+ if (valueInMap == null) {
+ throw new IllegalStateException("Write completed concurrently, expected this task: " + ChunkDataTask.this.toString() + ", report this!");
+ }
+ if (valueInMap != ChunkDataTask.this) {
+ throw new IllegalStateException("Chunk task mismatch, expected this task: " + ChunkDataTask.this.toString() + ", got: " + valueInMap.toString() + ", report this!");
+ }
+ return valueInMap.inProgressWrite == null ? null : valueInMap;
+ });
+
+ if (inMap == null) {
+ return; // set the task value to null, indicating we're done
+ }
+
+ // not null, which means there was a concurrent write
+ write = this.inProgressWrite;
+ }
+
+ // check if another process is writing
+ try {
+ this.world.checkSession();
+ } catch (final ExceptionWorldConflict ex) {
+ LOGGER.fatal("Couldn't save chunk; already in use by another instance of Minecraft?", ex);
+ // we don't need to set the write counter to -1 as we know at this stage there's no point in re-scheduling
+ // writes since they'll fail anyways.
+ write.wrote.complete(PaperFileIOThread.FAILURE_VALUE); // Hack - However we need to fail the write
+ return;
+ }
+
+ for (;;) {
+ final long writeCounter;
+ final NBTTagCompound data;
+
+ //noinspection SynchronizationOnLocalVariableOrMethodParameter
+ synchronized (write) {
+ writeCounter = write.writeCounter;
+ data = write.data;
+ }
+
+ boolean failedWrite = false;
+
+ try {
+ this.taskController.writeData(this.x, this.z, data);
+ } catch (final Throwable thr) {
+ if (thr instanceof ThreadDeath) {
+ throw (ThreadDeath)thr;
+ }
+ LOGGER.fatal("Failed to write chunk data for task: " + this.toString(), thr);
+ failedWrite = true;
+ }
+
+ boolean finalFailWrite = failedWrite;
+
+ ChunkDataTask inMap = this.taskController.tasks.compute(chunkKey, (final Long keyInMap, final ChunkDataTask valueInMap) -> {
+ if (valueInMap == null) {
+ ChunkDataTask.this.inProgressWrite.wrote.complete(PaperFileIOThread.FAILURE_VALUE); // Hack
+ throw new IllegalStateException("Write completed concurrently, expected this task: " + ChunkDataTask.this.toString() + ", report this!");
+ }
+ if (valueInMap != ChunkDataTask.this) {
+ ChunkDataTask.this.inProgressWrite.wrote.complete(PaperFileIOThread.FAILURE_VALUE); // Hack
+ throw new IllegalStateException("Chunk task mismatch, expected this task: " + ChunkDataTask.this.toString() + ", got: " + valueInMap.toString() + ", report this!");
+ }
+ if (valueInMap.inProgressWrite.writeCounter == writeCounter) {
+ if (finalFailWrite) {
+ valueInMap.inProgressWrite.writeCounter = -1L;
+ valueInMap.inProgressWrite.wrote.complete(PaperFileIOThread.FAILURE_VALUE);
+ } else {
+ valueInMap.inProgressWrite.wrote.complete(data);
+ }
+
+ return null;
+ }
+ return valueInMap;
+ // Hack end
+ });
+
+ if (inMap == null) {
+ // write counter matched, so we wrote the most up-to-date pending data, we're done here
+ // or we failed to write and successfully set the write counter to -1
+ return; // we're done here
+ }
+
+ // fetch & write new data
+ continue;
+ }
+ }
+ }
+}
diff --git a/src/main/java/com/destroystokyo/paper/io/PrioritizedTaskQueue.java b/src/main/java/com/destroystokyo/paper/io/PrioritizedTaskQueue.java
new file mode 100644
index 000000000..78bd238f4
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/io/PrioritizedTaskQueue.java
@@ -0,0 +1,276 @@
+package com.destroystokyo.paper.io;
+
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+public class PrioritizedTaskQueue {
+
+ // lower numbers are a higher priority (except < 0)
+ // higher priorities are always executed before lower priorities
+
+ /**
+ * Priority value indicating the task has completed or is being completed.
+ */
+ public static final int COMPLETING_PRIORITY = -1;
+
+ /**
+ * Highest priority, should only be used for main thread tasks or tasks that are blocking the main thread.
+ */
+ public static final int HIGHEST_PRIORITY = 0;
+
+ /**
+ * Should be only used in an IO task so that chunk loads do not wait on other IO tasks.
+ * This only exists because IO tasks are scheduled before chunk load tasks to decrease IO waiting times.
+ */
+ public static final int HIGHER_PRIORITY = 1;
+
+ /**
+ * Should be used for scheduling chunk loads/generation that would increase response times to users.
+ */
+ public static final int HIGH_PRIORITY = 2;
+
+ /**
+ * Default priority.
+ */
+ public static final int NORMAL_PRIORITY = 3;
+
+ /**
+ * Use for tasks not at all critical and can potentially be delayed.
+ */
+ public static final int LOW_PRIORITY = 4;
+
+ /**
+ * Use for tasks that should "eventually" execute.
+ */
+ public static final int LOWEST_PRIORITY = 5;
+
+ private static final int TOTAL_PRIORITIES = 6;
+
+ final ConcurrentLinkedQueue[] queues = (ConcurrentLinkedQueue[])new ConcurrentLinkedQueue[TOTAL_PRIORITIES];
+
+ private final AtomicBoolean shutdown = new AtomicBoolean();
+
+ {
+ for (int i = 0; i < TOTAL_PRIORITIES; ++i) {
+ this.queues[i] = new ConcurrentLinkedQueue<>();
+ }
+ }
+
+ /**
+ * Returns whether the specified priority is valid
+ */
+ public static boolean validPriority(final int priority) {
+ return priority >= 0 && priority < TOTAL_PRIORITIES;
+ }
+
+ /**
+ * Queues a task.
+ * @throws IllegalStateException If the task has already been queued. Use {@link PrioritizedTask#raisePriority(int)} to
+ * raise a task's priority.
+ * This can also be thrown if the queue has shutdown.
+ */
+ public void add(final T task) throws IllegalStateException {
+ task.onQueue(this);
+ this.queues[task.getPriority()].add(task);
+ if (this.shutdown.get()) {
+ // note: we're not actually sure at this point if our task will go through
+ throw new IllegalStateException("Queue has shutdown, refusing to execute task " + IOUtil.genericToString(task));
+ }
+ }
+
+ /**
+ * Polls the highest priority task currently available. {@code null} if none.
+ */
+ public T poll() {
+ T task;
+ for (int i = 0; i < TOTAL_PRIORITIES; ++i) {
+ final ConcurrentLinkedQueue queue = this.queues[i];
+
+ while ((task = queue.poll()) != null) {
+ final int prevPriority = task.tryComplete(i);
+ if (prevPriority != COMPLETING_PRIORITY && prevPriority <= i) {
+ // if the prev priority was greater-than or equal to our current priority
+ return task;
+ }
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Returns whether this queue may have tasks queued.
+ *
+ * This operation is not atomic, but is MT-Safe.
+ *
+ * @return {@code true} if tasks may be queued, {@code false} otherwise
+ */
+ public boolean hasTasks() {
+ for (int i = 0; i < TOTAL_PRIORITIES; ++i) {
+ final ConcurrentLinkedQueue queue = this.queues[i];
+
+ if (queue.peek() != null) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Prevent further additions to this queue. Attempts to add after this call has completed (potentially during) will
+ * result in {@link IllegalStateException} being thrown.
+ *
+ * This operation is atomic with respect to other shutdown calls
+ *
+ *
+ * After this call has completed, regardless of return value, this queue will be shutdown.
+ *
+ * @return {@code true} if the queue was shutdown, {@code false} if it has shut down already
+ */
+ public boolean shutdown() {
+ return this.shutdown.getAndSet(false);
+ }
+
+ public abstract static class PrioritizedTask {
+
+ protected final AtomicReference queue = new AtomicReference<>();
+
+ protected final AtomicInteger priority;
+
+ protected PrioritizedTask() {
+ this(PrioritizedTaskQueue.NORMAL_PRIORITY);
+ }
+
+ protected PrioritizedTask(final int priority) {
+ if (!PrioritizedTaskQueue.validPriority(priority)) {
+ throw new IllegalArgumentException("Invalid priority " + priority);
+ }
+ this.priority = new AtomicInteger(priority);
+ }
+
+ /**
+ * Returns the current priority. Note that {@link PrioritizedTaskQueue#COMPLETING_PRIORITY} will be returned
+ * if this task is completing or has completed.
+ */
+ public final int getPriority() {
+ return this.priority.get();
+ }
+
+ /**
+ * Returns whether this task is scheduled to execute, or has been already executed.
+ */
+ public boolean isScheduled() {
+ return this.queue.get() != null;
+ }
+
+ final int tryComplete(final int minPriority) {
+ for (int curr = this.getPriorityVolatile();;) {
+ if (curr == COMPLETING_PRIORITY) {
+ return COMPLETING_PRIORITY;
+ }
+ if (curr > minPriority) {
+ // curr is lower priority
+ return curr;
+ }
+
+ if (curr == (curr = this.compareAndExchangePriorityVolatile(curr, COMPLETING_PRIORITY))) {
+ return curr;
+ }
+ continue;
+ }
+ }
+
+ /**
+ * Forces this task to be completed.
+ * @return {@code true} if the task was cancelled, {@code false} if the task has already completed or is being completed.
+ */
+ public boolean cancel() {
+ return this.exchangePriorityVolatile(PrioritizedTaskQueue.COMPLETING_PRIORITY) != PrioritizedTaskQueue.COMPLETING_PRIORITY;
+ }
+
+ /**
+ * Attempts to raise the priority to the priority level specified.
+ * @param priority Priority specified
+ * @return {@code true} if successful, {@code false} otherwise.
+ */
+ public boolean raisePriority(final int priority) {
+ if (!PrioritizedTaskQueue.validPriority(priority)) {
+ throw new IllegalArgumentException("Invalid priority");
+ }
+
+ for (int curr = this.getPriorityVolatile();;) {
+ if (curr == COMPLETING_PRIORITY) {
+ return false;
+ }
+ if (priority >= curr) {
+ return true;
+ }
+
+ if (curr == (curr = this.compareAndExchangePriorityVolatile(curr, priority))) {
+ PrioritizedTaskQueue queue = this.queue.get();
+ if (queue != null) {
+ //noinspection unchecked
+ queue.queues[priority].add(this); // silently fail on shutdown
+ }
+ return true;
+ }
+ continue;
+ }
+ }
+
+ /**
+ * Attempts to set this task's priority level to the level specified.
+ * @param priority Specified priority level.
+ * @return {@code true} if successful, {@code false} if this task is completing or has completed.
+ */
+ public boolean updatePriority(final int priority) {
+ if (!PrioritizedTaskQueue.validPriority(priority)) {
+ throw new IllegalArgumentException("Invalid priority");
+ }
+
+ for (int curr = this.getPriorityVolatile();;) {
+ if (curr == COMPLETING_PRIORITY) {
+ return false;
+ }
+ if (curr == priority) {
+ return true;
+ }
+
+ if (curr == (curr = this.compareAndExchangePriorityVolatile(curr, priority))) {
+ PrioritizedTaskQueue queue = this.queue.get();
+ if (queue != null) {
+ //noinspection unchecked
+ queue.queues[priority].add(this); // silently fail on shutdown
+ }
+ return true;
+ }
+ continue;
+ }
+ }
+
+ void onQueue(final PrioritizedTaskQueue queue) {
+ if (this.queue.getAndSet(queue) != null) {
+ throw new IllegalStateException("Already queued!");
+ }
+ }
+
+ /* priority */
+
+ protected final int getPriorityVolatile() {
+ return this.priority.get();
+ }
+
+ protected final int compareAndExchangePriorityVolatile(final int expect, final int update) {
+ if (this.priority.compareAndSet(expect, update)) {
+ return expect;
+ }
+ return this.priority.get();
+ }
+
+ protected final int exchangePriorityVolatile(final int value) {
+ return this.priority.getAndSet(value);
+ }
+ }
+}
diff --git a/src/main/java/com/destroystokyo/paper/io/QueueExecutorThread.java b/src/main/java/com/destroystokyo/paper/io/QueueExecutorThread.java
new file mode 100644
index 000000000..ee906b594
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/io/QueueExecutorThread.java
@@ -0,0 +1,241 @@
+package com.destroystokyo.paper.io;
+
+import net.minecraft.server.MinecraftServer;
+import org.apache.logging.log4j.Logger;
+
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.LockSupport;
+
+public class QueueExecutorThread extends Thread {
+
+ private static final Logger LOGGER = MinecraftServer.LOGGER;
+
+ protected final PrioritizedTaskQueue queue;
+ protected final long spinWaitTime;
+
+ protected volatile boolean closed;
+
+ protected final AtomicBoolean parked = new AtomicBoolean();
+
+ protected volatile ConcurrentLinkedQueue flushQueue = new ConcurrentLinkedQueue<>();
+ protected volatile long flushCycles;
+
+ public QueueExecutorThread(final PrioritizedTaskQueue queue) {
+ this(queue, (int)(1.e6)); // 1.0ms
+ }
+
+ public QueueExecutorThread(final PrioritizedTaskQueue queue, final long spinWaitTime) { // in ms
+ this.queue = queue;
+ this.spinWaitTime = spinWaitTime;
+ }
+
+ @Override
+ public void run() {
+ final long spinWaitTime = this.spinWaitTime;
+ main_loop:
+ for (;;) {
+ this.pollTasks(true);
+
+ // spinwait
+
+ final long start = System.nanoTime();
+
+ for (;;) {
+ // If we are interrpted for any reason, park() will always return immediately. Clear so that we don't needlessly use cpu in such an event.
+ Thread.interrupted();
+ LockSupport.parkNanos("Spinwaiting on tasks", 1000L); // 1us
+
+ if (this.pollTasks(true)) {
+ // restart loop, found tasks
+ continue main_loop;
+ }
+
+ if (this.handleClose()) {
+ return; // we're done
+ }
+
+ if ((System.nanoTime() - start) >= spinWaitTime) {
+ break;
+ }
+ }
+
+ if (this.handleClose()) {
+ return;
+ }
+
+ this.parked.set(true);
+
+ // We need to parse here to avoid a race condition where a thread queues a task before we set parked to true
+ // (i.e it will not notify us)
+ if (this.pollTasks(true)) {
+ this.parked.set(false);
+ continue;
+ }
+
+ if (this.handleClose()) {
+ return;
+ }
+
+ // we don't need to check parked before sleeping, but we do need to check parked in a do-while loop
+ // LockSupport.park() can fail for any reason
+ do {
+ Thread.interrupted();
+ LockSupport.park("Waiting on tasks");
+ } while (this.parked.get());
+ }
+ }
+
+ protected boolean handleClose() {
+ if (this.closed) {
+ this.pollTasks(true); // this ensures we've emptied the queue
+ this.handleFlushThreads(true);
+ return true;
+ }
+ return false;
+ }
+
+ protected boolean pollTasks(boolean flushTasks) {
+ Runnable task;
+ boolean ret = false;
+
+ while ((task = this.queue.poll()) != null) {
+ ret = true;
+ try {
+ task.run();
+ } catch (final Throwable throwable) {
+ if (throwable instanceof ThreadDeath) {
+ throw (ThreadDeath)throwable;
+ }
+ LOGGER.fatal("Exception thrown from prioritized runnable task in thread '" + this.getName() + "': " + IOUtil.genericToString(task), throwable);
+ }
+ }
+
+ if (flushTasks) {
+ this.handleFlushThreads(false);
+ }
+
+ return ret;
+ }
+
+ protected void handleFlushThreads(final boolean shutdown) {
+ Thread parking;
+ ConcurrentLinkedQueue flushQueue = this.flushQueue;
+ do {
+ ++flushCycles; // may be plain read opaque write
+ while ((parking = flushQueue.poll()) != null) {
+ LockSupport.unpark(parking);
+ }
+ } while (this.pollTasks(false));
+
+ if (shutdown) {
+ this.flushQueue = null;
+
+ // defend against a race condition where a flush thread double-checks right before we set to null
+ while ((parking = flushQueue.poll()) != null) {
+ LockSupport.unpark(parking);
+ }
+ }
+ }
+
+ /**
+ * Notify's this thread that a task has been added to its queue
+ * @return {@code true} if this thread was waiting for tasks, {@code false} if it is executing tasks
+ */
+ public boolean notifyTasks() {
+ if (this.parked.get() && this.parked.getAndSet(false)) {
+ LockSupport.unpark(this);
+ return true;
+ }
+ return false;
+ }
+
+ protected void queueTask(final T task) {
+ this.queue.add(task);
+ this.notifyTasks();
+ }
+
+ /**
+ * Waits until this thread's queue is empty.
+ *
+ * @throws IllegalStateException If the current thread is {@code this} thread.
+ */
+ public void flush() {
+ final Thread currentThread = Thread.currentThread();
+
+ if (currentThread == this) {
+ // avoid deadlock
+ throw new IllegalStateException("Cannot flush the queue executor thread while on the queue executor thread");
+ }
+
+ // order is important
+
+ int successes = 0;
+ long lastCycle = -1L;
+
+ do {
+ final ConcurrentLinkedQueue flushQueue = this.flushQueue;
+ if (flushQueue == null) {
+ return;
+ }
+
+ flushQueue.add(currentThread);
+
+ // double check flush queue
+ if (this.flushQueue == null) {
+ return;
+ }
+
+ final long currentCycle = this.flushCycles; // may be opaque read
+
+ if (currentCycle == lastCycle) {
+ Thread.yield();
+ continue;
+ }
+
+ // force response
+ this.parked.set(false);
+ LockSupport.unpark(this);
+
+ LockSupport.park("flushing queue executor thread");
+
+ // returns whether there are tasks queued, does not return whether there are tasks executing
+ // this is why we cycle twice twice through flush (we know a pollTask call is made after a flush cycle)
+ // we really only need to guarantee that the tasks this thread has queued has gone through, and can leave
+ // tasks queued concurrently that are unsychronized with this thread as undefined behavior
+ if (this.queue.hasTasks()) {
+ successes = 0;
+ } else {
+ ++successes;
+ }
+
+ } while (successes != 2);
+
+ }
+
+ /**
+ * Closes this queue executor's queue and optionally waits for it to empty.
+ *
+ * If wait is {@code true}, then the queue will be empty by the time this call completes.
+ *
+ *
+ * This function is MT-Safe.
+ *
+ * @param wait If this call is to wait until the queue is empty
+ * @param killQueue Whether to shutdown this thread's queue
+ * @return whether this thread shut down the queue
+ */
+ public boolean close(final boolean wait, final boolean killQueue) {
+ boolean ret = !killQueue ? false : this.queue.shutdown();
+ this.closed = true;
+
+ // force thread to respond to the shutdown
+ this.parked.set(false);
+ LockSupport.unpark(this);
+
+ if (wait) {
+ this.flush();
+ }
+ return ret;
+ }
+}
diff --git a/src/main/java/com/destroystokyo/paper/io/SyncLoadFinder.java b/src/main/java/com/destroystokyo/paper/io/SyncLoadFinder.java
new file mode 100644
index 000000000..59aec1032
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/io/SyncLoadFinder.java
@@ -0,0 +1,172 @@
+package com.destroystokyo.paper.io;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.mojang.datafixers.util.Pair;
+import it.unimi.dsi.fastutil.longs.Long2IntMap;
+import it.unimi.dsi.fastutil.longs.Long2IntOpenHashMap;
+import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import net.minecraft.server.World;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+public class SyncLoadFinder {
+
+ public static final boolean ENABLED = Boolean.getBoolean("paper.debug-sync-loads");
+
+ private static final WeakHashMap> SYNC_LOADS = new WeakHashMap<>();
+
+ private static final class SyncLoadInformation {
+
+ public int times;
+
+ public final Long2IntOpenHashMap coordinateTimes = new Long2IntOpenHashMap();
+ }
+
+ public static void logSyncLoad(final World world, final int chunkX, final int chunkZ) {
+ if (!ENABLED) {
+ return;
+ }
+
+ final ThrowableWithEquals stacktrace = new ThrowableWithEquals(Thread.currentThread().getStackTrace());
+
+ SYNC_LOADS.compute(world, (final World keyInMap, Object2ObjectOpenHashMap map) -> {
+ if (map == null) {
+ map = new Object2ObjectOpenHashMap<>();
+ }
+
+ map.compute(stacktrace, (ThrowableWithEquals keyInMap0, SyncLoadInformation valueInMap) -> {
+ if (valueInMap == null) {
+ valueInMap = new SyncLoadInformation();
+ }
+
+ ++valueInMap.times;
+
+ valueInMap.coordinateTimes.compute(IOUtil.getCoordinateKey(chunkX, chunkZ), (Long keyInMap1, Integer valueInMap1) -> {
+ return valueInMap1 == null ? Integer.valueOf(1) : Integer.valueOf(valueInMap1.intValue() + 1);
+ });
+
+ return valueInMap;
+ });
+
+ return map;
+ });
+ }
+
+ public static JsonObject serialize() {
+ final JsonObject ret = new JsonObject();
+
+ final JsonArray worldsData = new JsonArray();
+
+ for (final Map.Entry> entry : SYNC_LOADS.entrySet()) {
+ final World world = entry.getKey();
+
+ final JsonObject worldData = new JsonObject();
+
+ worldData.addProperty("name", world.getWorld().getName());
+
+ final List> data = new ArrayList<>();
+
+ entry.getValue().forEach((ThrowableWithEquals stacktrace, SyncLoadInformation times) -> {
+ data.add(new Pair<>(stacktrace, times));
+ });
+
+ data.sort((Pair pair1, Pair pair2) -> {
+ return Integer.compare(pair2.getSecond().times, pair1.getSecond().times); // reverse order
+ });
+
+ final JsonArray stacktraces = new JsonArray();
+
+ for (Pair pair : data) {
+ final JsonObject stacktrace = new JsonObject();
+
+ stacktrace.addProperty("times", pair.getSecond().times);
+
+ final JsonArray traces = new JsonArray();
+
+ for (StackTraceElement element : pair.getFirst().stacktrace) {
+ traces.add(String.valueOf(element));
+ }
+
+ stacktrace.add("stacktrace", traces);
+
+ final JsonArray coordinates = new JsonArray();
+
+ for (Long2IntMap.Entry coordinate : pair.getSecond().coordinateTimes.long2IntEntrySet()) {
+ final long key = coordinate.getLongKey();
+ final int times = coordinate.getIntValue();
+ coordinates.add("(" + IOUtil.getCoordinateX(key) + "," + IOUtil.getCoordinateZ(key) + "): " + times);
+ }
+
+ stacktrace.add("coordinates", coordinates);
+
+ stacktraces.add(stacktrace);
+ }
+
+
+ worldData.add("stacktraces", stacktraces);
+ worldsData.add(worldData);
+ }
+
+ ret.add("worlds", worldsData);
+
+ return ret;
+ }
+
+ static final class ThrowableWithEquals {
+
+ private final StackTraceElement[] stacktrace;
+ private final int hash;
+
+ public ThrowableWithEquals(final StackTraceElement[] stacktrace) {
+ this.stacktrace = stacktrace;
+ this.hash = ThrowableWithEquals.hash(stacktrace);
+ }
+
+ public static int hash(final StackTraceElement[] stacktrace) {
+ int hash = 0;
+
+ for (int i = 0; i < stacktrace.length; ++i) {
+ hash *= 31;
+ hash += stacktrace[i].hashCode();
+ }
+
+ return hash;
+ }
+
+ @Override
+ public int hashCode() {
+ return this.hash;
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (obj == null || obj.getClass() != this.getClass()) {
+ return false;
+ }
+
+ final ThrowableWithEquals other = (ThrowableWithEquals)obj;
+ final StackTraceElement[] otherStackTrace = other.stacktrace;
+
+ if (this.stacktrace.length != otherStackTrace.length) {
+ return false;
+ }
+
+ if (this == obj) {
+ return true;
+ }
+
+ for (int i = 0; i < this.stacktrace.length; ++i) {
+ if (!this.stacktrace[i].equals(otherStackTrace[i])) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+ }
+}
diff --git a/src/main/java/com/destroystokyo/paper/io/chunk/ChunkLoadTask.java b/src/main/java/com/destroystokyo/paper/io/chunk/ChunkLoadTask.java
new file mode 100644
index 000000000..305da4786
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/io/chunk/ChunkLoadTask.java
@@ -0,0 +1,149 @@
+package com.destroystokyo.paper.io.chunk;
+
+import co.aikar.timings.Timing;
+import com.destroystokyo.paper.io.PaperFileIOThread;
+import com.destroystokyo.paper.io.IOUtil;
+import net.minecraft.server.ChunkCoordIntPair;
+import net.minecraft.server.ChunkRegionLoader;
+import net.minecraft.server.PlayerChunkMap;
+import net.minecraft.server.WorldServer;
+
+import java.util.ArrayDeque;
+import java.util.function.Consumer;
+
+public final class ChunkLoadTask extends ChunkTask {
+
+ public boolean cancelled;
+
+ Consumer onComplete;
+ public PaperFileIOThread.ChunkData chunkData;
+
+ private boolean hasCompleted;
+
+ public ChunkLoadTask(final WorldServer world, final int chunkX, final int chunkZ, final int priority,
+ final ChunkTaskManager taskManager,
+ final Consumer onComplete) {
+ super(world, chunkX, chunkZ, priority, taskManager);
+ this.onComplete = onComplete;
+ }
+
+ private static final ArrayDeque EMPTY_QUEUE = new ArrayDeque<>();
+
+ private static ChunkRegionLoader.InProgressChunkHolder createEmptyHolder() {
+ return new ChunkRegionLoader.InProgressChunkHolder(null, EMPTY_QUEUE);
+ }
+
+ @Override
+ public void run() {
+ try {
+ this.executeTask();
+ } catch (final Throwable ex) {
+ PaperFileIOThread.LOGGER.error("Failed to execute chunk load task: " + this.toString(), ex);
+ if (!this.hasCompleted) {
+ this.complete(ChunkLoadTask.createEmptyHolder());
+ }
+ }
+ }
+
+ private boolean checkCancelled() {
+ if (this.cancelled) {
+ // IntelliJ does not understand writes may occur to cancelled concurrently.
+ return this.taskManager.chunkLoadTasks.compute(Long.valueOf(IOUtil.getCoordinateKey(this.chunkX, this.chunkZ)), (final Long keyInMap, final ChunkLoadTask valueInMap) -> {
+ if (valueInMap != ChunkLoadTask.this) {
+ throw new IllegalStateException("Expected this task to be scheduled, but another was! Other: " + valueInMap + ", current: " + ChunkLoadTask.this);
+ }
+
+ if (valueInMap.cancelled) {
+ return null;
+ }
+ return valueInMap;
+ }) == null;
+ }
+ return false;
+ }
+
+ public void executeTask() {
+ if (this.checkCancelled()) {
+ return;
+ }
+
+ // either executed synchronously or asynchronously
+ final PaperFileIOThread.ChunkData chunkData = this.chunkData;
+
+ if (chunkData.poiData == PaperFileIOThread.FAILURE_VALUE || chunkData.chunkData == PaperFileIOThread.FAILURE_VALUE) {
+ PaperFileIOThread.LOGGER.error("Could not load chunk for task: " + this.toString() + ", file IO thread has dumped the relevant exception above");
+ this.complete(ChunkLoadTask.createEmptyHolder());
+ return;
+ }
+
+ if (chunkData.chunkData == null) {
+ // not on disk
+ this.complete(ChunkLoadTask.createEmptyHolder());
+ return;
+ }
+
+ final ChunkCoordIntPair chunkPos = new ChunkCoordIntPair(this.chunkX, this.chunkZ);
+
+ final PlayerChunkMap chunkManager = this.world.getChunkProvider().playerChunkMap;
+
+ try (Timing ignored = this.world.timings.chunkIOStage1.startTimingIfSync()) {
+ final ChunkRegionLoader.InProgressChunkHolder chunkHolder;
+
+ // apply fixes
+
+ try {
+ if (chunkData.poiData != null) {
+ chunkData.poiData = chunkData.poiData.clone(); // clone data for safety, file IO thread does not clone
+ }
+ chunkData.chunkData = chunkManager.getChunkData(this.world.getWorldProvider().getDimensionManager(),
+ chunkManager.getWorldPersistentDataSupplier(), chunkData.chunkData.clone(), chunkPos, this.world); // clone data for safety, file IO thread does not clone
+ } catch (final Throwable ex) {
+ PaperFileIOThread.LOGGER.error("Could not apply datafixers for chunk task: " + this.toString(), ex);
+ this.complete(ChunkLoadTask.createEmptyHolder());
+ }
+
+ if (this.checkCancelled()) {
+ return;
+ }
+
+ try {
+ this.world.getChunkProvider().playerChunkMap.updateChunkStatusOnDisk(chunkPos, chunkData.chunkData);
+ } catch (final Throwable ex) {
+ PaperFileIOThread.LOGGER.warn("Failed to update chunk status cache for task: " + this.toString(), ex);
+ // non-fatal, continue
+ }
+
+ try {
+ chunkHolder = ChunkRegionLoader.loadChunk(this.world,
+ chunkManager.definedStructureManager, chunkManager.getVillagePlace(), chunkPos,
+ chunkData.chunkData, true);
+ } catch (final Throwable ex) {
+ PaperFileIOThread.LOGGER.error("Could not de-serialize chunk data for task: " + this.toString(), ex);
+ this.complete(ChunkLoadTask.createEmptyHolder());
+ return;
+ }
+
+ this.complete(chunkHolder);
+ }
+ }
+
+ private void complete(final ChunkRegionLoader.InProgressChunkHolder holder) {
+ this.hasCompleted = true;
+ holder.poiData = this.chunkData == null ? null : this.chunkData.poiData;
+
+ this.taskManager.chunkLoadTasks.compute(Long.valueOf(IOUtil.getCoordinateKey(this.chunkX, this.chunkZ)), (final Long keyInMap, final ChunkLoadTask valueInMap) -> {
+ if (valueInMap != ChunkLoadTask.this) {
+ throw new IllegalStateException("Expected this task to be scheduled, but another was! Other: " + valueInMap + ", current: " + ChunkLoadTask.this);
+ }
+ if (valueInMap.cancelled) {
+ return null;
+ }
+ try {
+ ChunkLoadTask.this.onComplete.accept(holder);
+ } catch (final Throwable thr) {
+ PaperFileIOThread.LOGGER.error("Failed to complete chunk data for task: " + this.toString(), thr);
+ }
+ return null;
+ });
+ }
+}
diff --git a/src/main/java/com/destroystokyo/paper/io/chunk/ChunkSaveTask.java b/src/main/java/com/destroystokyo/paper/io/chunk/ChunkSaveTask.java
new file mode 100644
index 000000000..60312b85f
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/io/chunk/ChunkSaveTask.java
@@ -0,0 +1,112 @@
+package com.destroystokyo.paper.io.chunk;
+
+import co.aikar.timings.Timing;
+import com.destroystokyo.paper.io.PaperFileIOThread;
+import com.destroystokyo.paper.io.IOUtil;
+import com.destroystokyo.paper.io.PrioritizedTaskQueue;
+import net.minecraft.server.ChunkRegionLoader;
+import net.minecraft.server.IAsyncTaskHandler;
+import net.minecraft.server.IChunkAccess;
+import net.minecraft.server.NBTTagCompound;
+import net.minecraft.server.WorldServer;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public final class ChunkSaveTask extends ChunkTask {
+
+ public final ChunkRegionLoader.AsyncSaveData asyncSaveData;
+ public final IChunkAccess chunk;
+ public final CompletableFuture onComplete = new CompletableFuture<>();
+
+ private final AtomicInteger attemptedPriority;
+
+ public ChunkSaveTask(final WorldServer world, final int chunkX, final int chunkZ, final int priority,
+ final ChunkTaskManager taskManager, final ChunkRegionLoader.AsyncSaveData asyncSaveData,
+ final IChunkAccess chunk) {
+ super(world, chunkX, chunkZ, priority, taskManager);
+ this.chunk = chunk;
+ this.asyncSaveData = asyncSaveData;
+ this.attemptedPriority = new AtomicInteger(priority);
+ }
+
+ @Override
+ public void run() {
+ // can be executed asynchronously or synchronously
+ final NBTTagCompound compound;
+
+ try (Timing ignored = this.world.timings.chunkUnloadDataSave.startTimingIfSync()) {
+ compound = ChunkRegionLoader.saveChunk(this.world, this.chunk, this.asyncSaveData);
+ } catch (final Throwable ex) {
+ // has a plugin modified something it should not have and made us CME?
+ PaperFileIOThread.LOGGER.error("Failed to serialize unloading chunk data for task: " + this.toString() + ", falling back to a synchronous execution", ex);
+
+ // Note: We add to the server thread queue here since this is what the server will drain tasks from
+ // when waiting for chunks
+ ChunkTaskManager.queueChunkWaitTask(() -> {
+ try (Timing ignored = this.world.timings.chunkUnloadDataSave.startTiming()) {
+ NBTTagCompound data = PaperFileIOThread.FAILURE_VALUE;
+
+ try {
+ data = ChunkRegionLoader.saveChunk(this.world, this.chunk, this.asyncSaveData);
+ PaperFileIOThread.LOGGER.info("Successfully serialized chunk data for task: " + this.toString() + " synchronously");
+ } catch (final Throwable ex1) {
+ PaperFileIOThread.LOGGER.fatal("Failed to synchronously serialize unloading chunk data for task: " + this.toString() + "! Chunk data will be lost", ex1);
+ }
+
+ ChunkSaveTask.this.complete(data);
+ }
+ });
+
+ return; // the main thread will now complete the data
+ }
+
+ this.complete(compound);
+ }
+
+ @Override
+ public boolean raisePriority(final int priority) {
+ if (!PrioritizedTaskQueue.validPriority(priority)) {
+ throw new IllegalStateException("Invalid priority: " + priority);
+ }
+
+ // we know priority is valid here
+ for (int curr = this.attemptedPriority.get();;) {
+ if (curr <= priority) {
+ break; // curr is higher/same priority
+ }
+ if (this.attemptedPriority.compareAndSet(curr, priority)) {
+ break;
+ }
+ curr = this.attemptedPriority.get();
+ }
+
+ return super.raisePriority(priority);
+ }
+
+ @Override
+ public boolean updatePriority(final int priority) {
+ if (!PrioritizedTaskQueue.validPriority(priority)) {
+ throw new IllegalStateException("Invalid priority: " + priority);
+ }
+ this.attemptedPriority.set(priority);
+ return super.updatePriority(priority);
+ }
+
+ private void complete(final NBTTagCompound compound) {
+ try {
+ this.onComplete.complete(compound);
+ } catch (final Throwable thr) {
+ PaperFileIOThread.LOGGER.error("Failed to complete chunk data for task: " + this.toString(), thr);
+ }
+ if (compound != PaperFileIOThread.FAILURE_VALUE) {
+ PaperFileIOThread.Holder.INSTANCE.scheduleSave(this.world, this.chunkX, this.chunkZ, null, compound, this.attemptedPriority.get());
+ }
+ this.taskManager.chunkSaveTasks.compute(Long.valueOf(IOUtil.getCoordinateKey(this.chunkX, this.chunkZ)), (final Long keyInMap, final ChunkSaveTask valueInMap) -> {
+ if (valueInMap != ChunkSaveTask.this) {
+ throw new IllegalStateException("Expected this task to be scheduled, but another was! Other: " + valueInMap + ", this: " + ChunkSaveTask.this);
+ }
+ return null;
+ });
+ }
+}
diff --git a/src/main/java/com/destroystokyo/paper/io/chunk/ChunkTask.java b/src/main/java/com/destroystokyo/paper/io/chunk/ChunkTask.java
new file mode 100644
index 000000000..1dfa8abfd
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/io/chunk/ChunkTask.java
@@ -0,0 +1,40 @@
+package com.destroystokyo.paper.io.chunk;
+
+import com.destroystokyo.paper.io.PaperFileIOThread;
+import com.destroystokyo.paper.io.PrioritizedTaskQueue;
+import net.minecraft.server.WorldServer;
+
+abstract class ChunkTask extends PrioritizedTaskQueue.PrioritizedTask implements Runnable {
+
+ public final WorldServer world;
+ public final int chunkX;
+ public final int chunkZ;
+ public final ChunkTaskManager taskManager;
+
+ public ChunkTask(final WorldServer world, final int chunkX, final int chunkZ, final int priority,
+ final ChunkTaskManager taskManager) {
+ super(priority);
+ this.world = world;
+ this.chunkX = chunkX;
+ this.chunkZ = chunkZ;
+ this.taskManager = taskManager;
+ }
+
+ @Override
+ public String toString() {
+ return "Chunk task: class:" + this.getClass().getName() + ", for world '" + this.world.getWorld().getName() +
+ "', (" + this.chunkX + "," + this.chunkZ + "), hashcode:" + this.hashCode() + ", priority: " + this.getPriority();
+ }
+
+ @Override
+ public boolean raisePriority(final int priority) {
+ PaperFileIOThread.Holder.INSTANCE.bumpPriority(this.world, this.chunkX, this.chunkZ, priority);
+ return super.raisePriority(priority);
+ }
+
+ @Override
+ public boolean updatePriority(final int priority) {
+ PaperFileIOThread.Holder.INSTANCE.setPriority(this.world, this.chunkX, this.chunkZ, priority);
+ return super.updatePriority(priority);
+ }
+}
diff --git a/src/main/java/com/destroystokyo/paper/io/chunk/ChunkTaskManager.java b/src/main/java/com/destroystokyo/paper/io/chunk/ChunkTaskManager.java
new file mode 100644
index 000000000..59d73bfad
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/io/chunk/ChunkTaskManager.java
@@ -0,0 +1,453 @@
+package com.destroystokyo.paper.io.chunk;
+
+import com.destroystokyo.paper.io.PaperFileIOThread;
+import com.destroystokyo.paper.io.IOUtil;
+import com.destroystokyo.paper.io.PrioritizedTaskQueue;
+import com.destroystokyo.paper.io.QueueExecutorThread;
+import net.minecraft.server.ChunkRegionLoader;
+import net.minecraft.server.IAsyncTaskHandler;
+import net.minecraft.server.IChunkAccess;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.NBTTagCompound;
+import net.minecraft.server.WorldServer;
+import org.apache.logging.log4j.Level;
+import org.bukkit.Bukkit;
+import org.spigotmc.AsyncCatcher;
+
+import java.util.ArrayDeque;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.function.Consumer;
+
+public final class ChunkTaskManager {
+
+ private final QueueExecutorThread[] workers;
+ private final WorldServer world;
+
+ private final PrioritizedTaskQueue queue;
+ private final boolean perWorldQueue;
+
+ final ConcurrentHashMap chunkLoadTasks = new ConcurrentHashMap<>(64, 0.5f);
+ final ConcurrentHashMap chunkSaveTasks = new ConcurrentHashMap<>(64, 0.5f);
+
+ private final PrioritizedTaskQueue chunkTasks = new PrioritizedTaskQueue<>(); // used if async chunks are disabled in config
+
+ protected static QueueExecutorThread[] globalWorkers;
+ protected static PrioritizedTaskQueue globalQueue;
+
+ protected static final ConcurrentLinkedQueue CHUNK_WAIT_QUEUE = new ConcurrentLinkedQueue<>();
+
+ public static final ArrayDeque WAITING_CHUNKS = new ArrayDeque<>(); // stack
+
+ private static final class ChunkInfo {
+
+ public final int chunkX;
+ public final int chunkZ;
+ public final WorldServer world;
+
+ public ChunkInfo(final int chunkX, final int chunkZ, final WorldServer world) {
+ this.chunkX = chunkX;
+ this.chunkZ = chunkZ;
+ this.world = world;
+ }
+
+ @Override
+ public String toString() {
+ return "[( " + this.chunkX + "," + this.chunkZ + ") in '" + this.world.getWorld().getName() + "']";
+ }
+ }
+
+ public static void pushChunkWait(final WorldServer world, final int chunkX, final int chunkZ) {
+ synchronized (WAITING_CHUNKS) {
+ WAITING_CHUNKS.push(new ChunkInfo(chunkX, chunkZ, world));
+ }
+ }
+
+ public static void popChunkWait() {
+ synchronized (WAITING_CHUNKS) {
+ WAITING_CHUNKS.pop();
+ }
+ }
+
+ public static String getChunkWaitInfo() {
+ synchronized (WAITING_CHUNKS) {
+ return WAITING_CHUNKS.toString();
+ }
+ }
+
+ public static void dumpAllChunkLoadInfo() {
+ synchronized (WAITING_CHUNKS) {
+ if (WAITING_CHUNKS.isEmpty()) {
+ return;
+ }
+
+ PaperFileIOThread.LOGGER.log(Level.ERROR, "Chunk wait task info below: ");
+
+ for (final ChunkInfo chunkInfo : WAITING_CHUNKS) {
+ final long key = IOUtil.getCoordinateKey(chunkInfo.chunkX, chunkInfo.chunkZ);
+ final ChunkLoadTask loadTask = chunkInfo.world.asyncChunkTaskManager.chunkLoadTasks.get(key);
+ final ChunkSaveTask saveTask = chunkInfo.world.asyncChunkTaskManager.chunkSaveTasks.get(key);
+
+ PaperFileIOThread.LOGGER.log(Level.ERROR, chunkInfo.chunkX + "," + chunkInfo.chunkZ + " in '" + chunkInfo.world.getWorld().getName() + ":");
+ PaperFileIOThread.LOGGER.log(Level.ERROR, "Load Task - " + (loadTask == null ? "none" : loadTask.toString()));
+ PaperFileIOThread.LOGGER.log(Level.ERROR, "Save Task - " + (saveTask == null ? "none" : saveTask.toString()));
+ // log current status of chunk to indicate whether we're waiting on generation or loading
+ net.minecraft.server.PlayerChunk chunkHolder = chunkInfo.world.getChunkProvider().playerChunkMap.getVisibleChunk(key);
+
+ if (chunkHolder == null) {
+ PaperFileIOThread.LOGGER.log(Level.ERROR, "Chunk Holder - null");
+ } else {
+ IChunkAccess chunk = chunkHolder.getAvailableChunkNow();
+ PaperFileIOThread.LOGGER.log(Level.ERROR, "Chunk Holder - non-null");
+ PaperFileIOThread.LOGGER.log(Level.ERROR, "Chunk Status - " + ((chunk == null) ? "null chunk" : chunk.getChunkStatus().toString()));
+ }
+
+ }
+ }
+ }
+
+ public static void initGlobalLoadThreads(int threads) {
+ if (threads <= 0 || globalWorkers != null) {
+ return;
+ }
+
+ globalWorkers = new QueueExecutorThread[threads];
+ globalQueue = new PrioritizedTaskQueue<>();
+
+ for (int i = 0; i < threads; ++i) {
+ globalWorkers[i] = new QueueExecutorThread<>(globalQueue, (long)0.10e6); //0.1ms
+ globalWorkers[i].setName("Paper Async Chunk Task Thread #" + i);
+ globalWorkers[i].setPriority(Thread.NORM_PRIORITY - 1);
+ globalWorkers[i].setUncaughtExceptionHandler((final Thread thread, final Throwable throwable) -> {
+ PaperFileIOThread.LOGGER.fatal("Thread '" + thread.getName() + "' threw an uncaught exception!", throwable);
+ });
+
+ globalWorkers[i].start();
+ }
+ }
+
+ /**
+ * Creates this chunk task manager to operate off the specified number of threads. If the specified number of threads is
+ * less-than or equal to 0, then this chunk task manager will operate off of the world's chunk task queue.
+ * @param world Specified world.
+ * @param threads Specified number of threads.
+ * @see net.minecraft.server.ChunkProviderServer#serverThreadQueue
+ */
+ public ChunkTaskManager(final WorldServer world, final int threads) {
+ this.world = world;
+ this.workers = threads <= 0 ? null : new QueueExecutorThread[threads];
+ this.queue = new PrioritizedTaskQueue<>();
+ this.perWorldQueue = true;
+
+ for (int i = 0; i < threads; ++i) {
+ this.workers[i] = new QueueExecutorThread<>(this.queue, (long)0.10e6); //0.1ms
+ this.workers[i].setName("Async chunk loader thread #" + i + " for world: " + world.getWorldData().getName());
+ this.workers[i].setPriority(Thread.NORM_PRIORITY - 1);
+ this.workers[i].setUncaughtExceptionHandler((final Thread thread, final Throwable throwable) -> {
+ PaperFileIOThread.LOGGER.fatal("Thread '" + thread.getName() + "' threw an uncaught exception!", throwable);
+ });
+
+ this.workers[i].start();
+ }
+ }
+
+ /**
+ * Creates the chunk task manager to work from the global workers. When {@link #close(boolean)} is invoked,
+ * the global queue is not shutdown. If the global workers is configured to be disabled or use 0 threads, then
+ * this chunk task manager will operate off of the world's chunk task queue.
+ * @param world The world that this task manager is responsible for
+ * @see net.minecraft.server.ChunkProviderServer#serverThreadQueue
+ */
+ public ChunkTaskManager(final WorldServer world) {
+ this.world = world;
+ this.workers = globalWorkers;
+ this.queue = globalQueue;
+ this.perWorldQueue = false;
+ }
+
+ public boolean pollNextChunkTask() {
+ final ChunkTask task = this.chunkTasks.poll();
+
+ if (task != null) {
+ task.run();
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Polls and runs the next available chunk wait queue task. This is to be used when the server is waiting on a chunk queue.
+ * (per-world can cause issues if all the worker threads are blocked waiting for a response from the main thread)
+ */
+ public static boolean pollChunkWaitQueue() {
+ final Runnable run = CHUNK_WAIT_QUEUE.poll();
+ if (run != null) {
+ run.run();
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Queues a chunk wait task. Note that this will execute out of order with respect to tasks scheduled on a world's
+ * chunk task queue, since this is the global chunk wait queue.
+ */
+ public static void queueChunkWaitTask(final Runnable runnable) {
+ CHUNK_WAIT_QUEUE.add(runnable);
+ }
+
+ private static void drainChunkWaitQueue() {
+ Runnable run;
+ while ((run = CHUNK_WAIT_QUEUE.poll()) != null) {
+ run.run();
+ }
+ }
+
+ /**
+ * The exact same as {@link #scheduleChunkLoad(int, int, int, Consumer, boolean)}, except that the chunk data is provided as
+ * the {@code data} parameter.
+ */
+ public ChunkLoadTask scheduleChunkLoad(final int chunkX, final int chunkZ, final int priority,
+ final Consumer onComplete,
+ final boolean intendingToBlock, final CompletableFuture dataFuture) {
+ final WorldServer world = this.world;
+
+ return this.chunkLoadTasks.compute(Long.valueOf(IOUtil.getCoordinateKey(chunkX, chunkZ)), (final Long keyInMap, final ChunkLoadTask valueInMap) -> {
+ if (valueInMap != null) {
+ if (!valueInMap.cancelled) {
+ throw new IllegalStateException("Double scheduling chunk load for task: " + valueInMap.toString());
+ }
+ valueInMap.cancelled = false;
+ valueInMap.onComplete = onComplete;
+ return valueInMap;
+ }
+
+ final ChunkLoadTask ret = new ChunkLoadTask(world, chunkX, chunkZ, priority, ChunkTaskManager.this, onComplete);
+
+ dataFuture.thenAccept((final NBTTagCompound data) -> {
+ final boolean failed = data == PaperFileIOThread.FAILURE_VALUE;
+ PaperFileIOThread.Holder.INSTANCE.loadChunkDataAsync(world, chunkX, chunkZ, priority, (final PaperFileIOThread.ChunkData chunkData) -> {
+ ret.chunkData = chunkData;
+ if (!failed) {
+ chunkData.chunkData = data;
+ }
+ ChunkTaskManager.this.internalSchedule(ret); // only schedule to the worker threads here
+ }, true, failed, intendingToBlock); // read data off disk if the future fails
+ });
+
+ return ret;
+ });
+ }
+
+ public void cancelChunkLoad(final int chunkX, final int chunkZ) {
+ this.chunkLoadTasks.compute(IOUtil.getCoordinateKey(chunkX, chunkZ), (final Long keyInMap, final ChunkLoadTask valueInMap) -> {
+ if (valueInMap == null) {
+ return null;
+ }
+
+ if (valueInMap.cancelled) {
+ PaperFileIOThread.LOGGER.warn("Task " + valueInMap.toString() + " is already cancelled!");
+ }
+ valueInMap.cancelled = true;
+ if (valueInMap.cancel()) {
+ return null;
+ }
+
+ return valueInMap;
+ });
+ }
+
+ /**
+ * Schedules an asynchronous chunk load for the specified coordinates. The onComplete parameter may be invoked asynchronously
+ * on a worker thread or on the world's chunk executor queue. As such the code that is executed for the parameter should be
+ * carefully chosen.
+ * @param chunkX Chunk's x coordinate
+ * @param chunkZ Chunk's z coordinate
+ * @param priority Priority for this task
+ * @param onComplete The consumer to invoke with the {@link net.minecraft.server.ChunkRegionLoader.InProgressChunkHolder} object once this task is complete
+ * @param intendingToBlock Whether the caller is intending to block on this task completing (this is a performance tune, and has no adverse side-effects)
+ * @return The {@link ChunkLoadTask} associated with
+ */
+ public ChunkLoadTask scheduleChunkLoad(final int chunkX, final int chunkZ, final int priority,
+ final Consumer onComplete,
+ final boolean intendingToBlock) {
+ final WorldServer world = this.world;
+
+ return this.chunkLoadTasks.compute(Long.valueOf(IOUtil.getCoordinateKey(chunkX, chunkZ)), (final Long keyInMap, final ChunkLoadTask valueInMap) -> {
+ if (valueInMap != null) {
+ if (!valueInMap.cancelled) {
+ throw new IllegalStateException("Double scheduling chunk load for task: " + valueInMap.toString());
+ }
+ valueInMap.cancelled = false;
+ valueInMap.onComplete = onComplete;
+ return valueInMap;
+ }
+
+ final ChunkLoadTask ret = new ChunkLoadTask(world, chunkX, chunkZ, priority, ChunkTaskManager.this, onComplete);
+
+ PaperFileIOThread.Holder.INSTANCE.loadChunkDataAsync(world, chunkX, chunkZ, priority, (final PaperFileIOThread.ChunkData chunkData) -> {
+ ret.chunkData = chunkData;
+ ChunkTaskManager.this.internalSchedule(ret); // only schedule to the worker threads here
+ }, true, true, intendingToBlock);
+
+ return ret;
+ });
+ }
+
+ /**
+ * Schedules an async save for the specified chunk. The chunk, at the beginning of this call, must be completely unloaded
+ * from the world.
+ * @param chunkX Chunk's x coordinate
+ * @param chunkZ Chunk's z coordinate
+ * @param priority Priority for this task
+ * @param asyncSaveData Async save data. See {@link ChunkRegionLoader#getAsyncSaveData(WorldServer, IChunkAccess)}
+ * @param chunk Chunk to save
+ * @return The {@link ChunkSaveTask} associated with the save task.
+ */
+ public ChunkSaveTask scheduleChunkSave(final int chunkX, final int chunkZ, final int priority,
+ final ChunkRegionLoader.AsyncSaveData asyncSaveData,
+ final IChunkAccess chunk) {
+ AsyncCatcher.catchOp("chunk save schedule");
+
+ final WorldServer world = this.world;
+
+ return this.chunkSaveTasks.compute(Long.valueOf(IOUtil.getCoordinateKey(chunkX, chunkZ)), (final Long keyInMap, final ChunkSaveTask valueInMap) -> {
+ if (valueInMap != null) {
+ throw new IllegalStateException("Double scheduling chunk save for task: " + valueInMap.toString());
+ }
+
+ final ChunkSaveTask ret = new ChunkSaveTask(world, chunkX, chunkZ, priority, ChunkTaskManager.this, asyncSaveData, chunk);
+
+ ChunkTaskManager.this.internalSchedule(ret);
+
+ return ret;
+ });
+ }
+
+ /**
+ * Returns a completable future which will be completed with the un-copied chunk data for an in progress async save.
+ * Returns {@code null} if no save is in progress.
+ * @param chunkX Chunk's x coordinate
+ * @param chunkZ Chunk's z coordinate
+ */
+ public CompletableFuture getChunkSaveFuture(final int chunkX, final int chunkZ) {
+ final ChunkSaveTask chunkSaveTask = this.chunkSaveTasks.get(Long.valueOf(IOUtil.getCoordinateKey(chunkX, chunkZ)));
+ if (chunkSaveTask == null) {
+ return null;
+ }
+ return chunkSaveTask.onComplete;
+ }
+
+ /**
+ * Returns the chunk object being used to serialize data async for an unloaded chunk. Note that modifying this chunk
+ * is not safe to do as another thread is handling its save. The chunk is also not loaded into the world.
+ * @param chunkX Chunk's x coordinate
+ * @param chunkZ Chunk's z coordinate
+ * @return Chunk object for an in-progress async save, or {@code null} if no save is in progress
+ */
+ public IChunkAccess getChunkInSaveProgress(final int chunkX, final int chunkZ) {
+ final ChunkSaveTask chunkSaveTask = this.chunkSaveTasks.get(Long.valueOf(IOUtil.getCoordinateKey(chunkX, chunkZ)));
+ if (chunkSaveTask == null) {
+ return null;
+ }
+ return chunkSaveTask.chunk;
+ }
+
+ public void flush() {
+ // flush here since we schedule tasks on the IO thread that can schedule tasks here
+ drainChunkWaitQueue();
+ PaperFileIOThread.Holder.INSTANCE.flush();
+ drainChunkWaitQueue();
+
+ if (this.workers == null) {
+ if (Bukkit.isPrimaryThread()) {
+ ((IAsyncTaskHandler)this.world.getChunkProvider().serverThreadQueue).executeAll();
+ } else {
+ CompletableFuture wait = new CompletableFuture<>();
+ MinecraftServer.getServer().scheduleOnMain(() -> {
+ ((IAsyncTaskHandler)this.world.getChunkProvider().serverThreadQueue).executeAll();
+ });
+ wait.join();
+ }
+ } else {
+ for (final QueueExecutorThread worker : this.workers) {
+ worker.flush();
+ }
+ }
+
+ // flush again since tasks we execute async saves
+ drainChunkWaitQueue();
+ PaperFileIOThread.Holder.INSTANCE.flush();
+ }
+
+ public void close(final boolean wait) {
+ // flush here since we schedule tasks on the IO thread that can schedule tasks to this task manager
+ // we do this regardless of the wait param since after we invoke close no tasks can be queued
+ PaperFileIOThread.Holder.INSTANCE.flush();
+
+ if (this.workers == null) {
+ if (wait) {
+ this.flush();
+ }
+ return;
+ }
+
+ if (this.workers != globalWorkers) {
+ for (final QueueExecutorThread worker : this.workers) {
+ worker.close(false, this.perWorldQueue);
+ }
+ }
+
+ if (wait) {
+ this.flush();
+ }
+ }
+
+ public void raisePriority(final int chunkX, final int chunkZ, final int priority) {
+ final Long chunkKey = Long.valueOf(IOUtil.getCoordinateKey(chunkX, chunkZ));
+
+ ChunkSaveTask chunkSaveTask = this.chunkSaveTasks.get(chunkKey);
+ if (chunkSaveTask != null) {
+ final boolean raised = chunkSaveTask.raisePriority(priority);
+ if (chunkSaveTask.isScheduled() && raised) {
+ // only notify if we're in queue to be executed
+ this.internalScheduleNotify();
+ }
+ }
+
+ ChunkLoadTask chunkLoadTask = this.chunkLoadTasks.get(chunkKey);
+ if (chunkLoadTask != null) {
+ final boolean raised = chunkLoadTask.raisePriority(priority);
+ if (chunkLoadTask.isScheduled() && raised) {
+ // only notify if we're in queue to be executed
+ this.internalScheduleNotify();
+ }
+ }
+ }
+
+ protected void internalSchedule(final ChunkTask task) {
+ if (this.workers == null) {
+ this.chunkTasks.add(task);
+ return;
+ }
+
+ // It's important we order the task to be executed before notifying. Avoid a race condition where the worker thread
+ // wakes up and goes to sleep before we actually schedule (or it's just about to sleep)
+ this.queue.add(task);
+ this.internalScheduleNotify();
+ }
+
+ protected void internalScheduleNotify() {
+ if (this.workers == null) {
+ return;
+ }
+ for (final QueueExecutorThread worker : this.workers) {
+ if (worker.notifyTasks()) {
+ // break here since we only want to wake up one worker for scheduling one task
+ break;
+ }
+ }
+ }
+
+}
diff --git a/src/main/java/com/destroystokyo/paper/log/LogFullPolicy.java b/src/main/java/com/destroystokyo/paper/log/LogFullPolicy.java
new file mode 100644
index 000000000..db652a1f7
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/log/LogFullPolicy.java
@@ -0,0 +1,17 @@
+package com.destroystokyo.paper.log;
+
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.core.async.AsyncQueueFullPolicy;
+import org.apache.logging.log4j.core.async.EventRoute;
+
+public final class LogFullPolicy implements AsyncQueueFullPolicy {
+
+ /*
+ * Prevents log calls being logged out of order when the log queue is full.
+ */
+
+ @Override
+ public EventRoute getRoute(final long backgroundThreadId, final Level level) {
+ return EventRoute.ENQUEUE;
+ }
+}
diff --git a/src/main/java/com/destroystokyo/paper/profile/CraftPlayerProfile.java b/src/main/java/com/destroystokyo/paper/profile/CraftPlayerProfile.java
index a7dbe11cb..b151a13c1 100644
--- a/src/main/java/com/destroystokyo/paper/profile/CraftPlayerProfile.java
+++ b/src/main/java/com/destroystokyo/paper/profile/CraftPlayerProfile.java
@@ -1,18 +1,17 @@
package com.destroystokyo.paper.profile;
import com.destroystokyo.paper.PaperConfig;
+import com.google.common.base.Charsets;
import com.mojang.authlib.GameProfile;
import com.mojang.authlib.properties.Property;
import com.mojang.authlib.properties.PropertyMap;
-
-import net.minecraft.server.AkarinUserCache;
import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.UserCache;
import org.bukkit.craftbukkit.entity.CraftPlayer;
import org.spigotmc.SpigotConfig;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-
import java.util.AbstractSet;
import java.util.Collection;
import java.util.Iterator;
@@ -144,9 +143,7 @@ public class CraftPlayerProfile implements PlayerProfile {
}
MinecraftServer server = MinecraftServer.getServer();
String name = profile.getName();
- // Akarin start
- AkarinUserCache userCache = server.getModernUserCache();
- /*
+ UserCache userCache = server.getUserCache();
if (profile.getId() == null) {
final GameProfile profile;
boolean isOnlineMode = server.getOnlineMode() || (SpigotConfig.bungee && PaperConfig.bungeeOnlineMode);
@@ -168,24 +165,7 @@ public class CraftPlayerProfile implements PlayerProfile {
this.profile = profile;
}
}
- */
-
- if (profile.getId() == null) {
- if (lookupName) {
- profile = userCache.acquire(name);
- } else {
- GameProfile peeked = userCache.peek(name);
-
- if (peeked != null)
- profile = peeked;
- }
- }
-
- if (profile.getName() == null)
- profile = userCache.acquire(name);
-
- return profile.isComplete();
- // Akarin end
+ return this.profile.isComplete();
}
public boolean complete(boolean textures) {
diff --git a/src/main/java/com/destroystokyo/paper/util/PlayerMobDistanceMap.java b/src/main/java/com/destroystokyo/paper/util/PlayerMobDistanceMap.java
new file mode 100644
index 000000000..9ebd7ecb7
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/util/PlayerMobDistanceMap.java
@@ -0,0 +1,253 @@
+package com.destroystokyo.paper.util;
+
+import it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap;
+import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
+import it.unimi.dsi.fastutil.objects.ObjectLinkedOpenHashSet;
+import net.minecraft.server.ChunkCoordIntPair;
+import net.minecraft.server.EntityPlayer;
+import net.minecraft.server.SectionPosition;
+import org.spigotmc.AsyncCatcher;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/** @author Spottedleaf */
+public final class PlayerMobDistanceMap {
+
+ private static final PooledHashSets.PooledObjectLinkedOpenHashSet EMPTY_SET = new PooledHashSets.PooledObjectLinkedOpenHashSet<>();
+
+ private final Map players = new HashMap<>();
+ // we use linked for better iteration.
+ private final Long2ObjectOpenHashMap> playerMap = new Long2ObjectOpenHashMap<>(32, 0.5f);
+ private int viewDistance;
+
+ private final PooledHashSets pooledHashSets = new PooledHashSets<>();
+
+ public PooledHashSets.PooledObjectLinkedOpenHashSet getPlayersInRange(final ChunkCoordIntPair chunkPos) {
+ return this.getPlayersInRange(chunkPos.x, chunkPos.z);
+ }
+
+ public PooledHashSets.PooledObjectLinkedOpenHashSet getPlayersInRange(final int chunkX, final int chunkZ) {
+ return this.playerMap.getOrDefault(ChunkCoordIntPair.pair(chunkX, chunkZ), EMPTY_SET);
+ }
+
+ public void update(final List currentPlayers, final int newViewDistance) {
+ AsyncCatcher.catchOp("Distance map update");
+ final ObjectLinkedOpenHashSet gone = new ObjectLinkedOpenHashSet<>(this.players.keySet());
+
+ final int oldViewDistance = this.viewDistance;
+ this.viewDistance = newViewDistance;
+
+ for (final EntityPlayer player : currentPlayers) {
+ if (player.isSpectator() || !player.affectsSpawning) {
+ continue; // will be left in 'gone' (or not added at all)
+ }
+
+ gone.remove(player);
+
+ final SectionPosition newPosition = player.getPlayerMapSection();
+ final SectionPosition oldPosition = this.players.put(player, newPosition);
+
+ if (oldPosition == null) {
+ this.addNewPlayer(player, newPosition, newViewDistance);
+ } else {
+ this.updatePlayer(player, oldPosition, newPosition, oldViewDistance, newViewDistance);
+ }
+ //this.validatePlayer(player, newViewDistance); // debug only
+ }
+
+ for (final EntityPlayer player : gone) {
+ final SectionPosition oldPosition = this.players.remove(player);
+ if (oldPosition != null) {
+ this.removePlayer(player, oldPosition, oldViewDistance);
+ }
+ }
+ }
+
+ // expensive op, only for debug
+ private void validatePlayer(final EntityPlayer player, final int viewDistance) {
+ int entiesGot = 0;
+ int expectedEntries = (2 * viewDistance + 1);
+ expectedEntries *= expectedEntries;
+
+ final SectionPosition currPosition = player.getPlayerMapSection();
+
+ final int centerX = currPosition.getX();
+ final int centerZ = currPosition.getZ();
+
+ for (final Long2ObjectLinkedOpenHashMap.Entry> entry : this.playerMap.long2ObjectEntrySet()) {
+ final long key = entry.getLongKey();
+ final PooledHashSets.PooledObjectLinkedOpenHashSet map = entry.getValue();
+
+ if (map.referenceCount == 0) {
+ throw new IllegalStateException("Invalid map");
+ }
+
+ if (map.set.contains(player)) {
+ ++entiesGot;
+
+ final int chunkX = ChunkCoordIntPair.getX(key);
+ final int chunkZ = ChunkCoordIntPair.getZ(key);
+
+ final int dist = Math.max(Math.abs(chunkX - centerX), Math.abs(chunkZ - centerZ));
+
+ if (dist > viewDistance) {
+ throw new IllegalStateException("Expected view distance " + viewDistance + ", got " + dist);
+ }
+ }
+ }
+
+ if (entiesGot != expectedEntries) {
+ throw new IllegalStateException("Expected " + expectedEntries + ", got " + entiesGot);
+ }
+ }
+
+ private void addPlayerTo(final EntityPlayer player, final int chunkX, final int chunkZ) {
+ this.playerMap.compute(ChunkCoordIntPair.pair(chunkX, chunkZ), (final Long key, final PooledHashSets.PooledObjectLinkedOpenHashSet players) -> {
+ if (players == null) {
+ return player.cachedSingleMobDistanceMap;
+ } else {
+ return PlayerMobDistanceMap.this.pooledHashSets.findMapWith(players, player);
+ }
+ });
+ }
+
+ private void removePlayerFrom(final EntityPlayer player, final int chunkX, final int chunkZ) {
+ this.playerMap.compute(ChunkCoordIntPair.pair(chunkX, chunkZ), (final Long keyInMap, final PooledHashSets.PooledObjectLinkedOpenHashSet players) -> {
+ return PlayerMobDistanceMap.this.pooledHashSets.findMapWithout(players, player); // rets null instead of an empty map
+ });
+ }
+
+ private void updatePlayer(final EntityPlayer player, final SectionPosition oldPosition, final SectionPosition newPosition, final int oldViewDistance, final int newViewDistance) {
+ final int toX = newPosition.getX();
+ final int toZ = newPosition.getZ();
+ final int fromX = oldPosition.getX();
+ final int fromZ = oldPosition.getZ();
+
+ final int dx = toX - fromX;
+ final int dz = toZ - fromZ;
+
+ final int totalX = Math.abs(fromX - toX);
+ final int totalZ = Math.abs(fromZ - toZ);
+
+ if (Math.max(totalX, totalZ) > (2 * oldViewDistance)) {
+ // teleported?
+ this.removePlayer(player, oldPosition, oldViewDistance);
+ this.addNewPlayer(player, newPosition, newViewDistance);
+ return;
+ }
+
+ // x axis is width
+ // z axis is height
+ // right refers to the x axis of where we moved
+ // top refers to the z axis of where we moved
+
+ if (oldViewDistance == newViewDistance) {
+ // same view distance
+
+ // used for relative positioning
+ final int up = 1 | (dz >> (Integer.SIZE - 1)); // 1 if dz >= 0, -1 otherwise
+ final int right = 1 | (dx >> (Integer.SIZE - 1)); // 1 if dx >= 0, -1 otherwise
+
+ // The area excluded by overlapping the two view distance squares creates four rectangles:
+ // Two on the left, and two on the right. The ones on the left we consider the "removed" section
+ // and on the right the "added" section.
+ // https://i.imgur.com/MrnOBgI.png is a reference image. Note that the outside border is not actually
+ // exclusive to the regions they surround.
+
+ // 4 points of the rectangle
+ int maxX; // exclusive
+ int minX; // inclusive
+ int maxZ; // exclusive
+ int minZ; // inclusive
+
+ if (dx != 0) {
+ // handle right addition
+
+ maxX = toX + (oldViewDistance * right) + right; // exclusive
+ minX = fromX + (oldViewDistance * right) + right; // inclusive
+ maxZ = fromZ + (oldViewDistance * up) + up; // exclusive
+ minZ = toZ - (oldViewDistance * up); // inclusive
+
+ for (int currX = minX; currX != maxX; currX += right) {
+ for (int currZ = minZ; currZ != maxZ; currZ += up) {
+ this.addPlayerTo(player, currX, currZ);
+ }
+ }
+ }
+
+ if (dz != 0) {
+ // handle up addition
+
+ maxX = toX + (oldViewDistance * right) + right; // exclusive
+ minX = toX - (oldViewDistance * right); // inclusive
+ maxZ = toZ + (oldViewDistance * up) + up; // exclusive
+ minZ = fromZ + (oldViewDistance * up) + up; // inclusive
+
+ for (int currX = minX; currX != maxX; currX += right) {
+ for (int currZ = minZ; currZ != maxZ; currZ += up) {
+ this.addPlayerTo(player, currX, currZ);
+ }
+ }
+ }
+
+ if (dx != 0) {
+ // handle left removal
+
+ maxX = toX - (oldViewDistance * right); // exclusive
+ minX = fromX - (oldViewDistance * right); // inclusive
+ maxZ = fromZ + (oldViewDistance * up) + up; // exclusive
+ minZ = toZ - (oldViewDistance * up); // inclusive
+
+ for (int currX = minX; currX != maxX; currX += right) {
+ for (int currZ = minZ; currZ != maxZ; currZ += up) {
+ this.removePlayerFrom(player, currX, currZ);
+ }
+ }
+ }
+
+ if (dz != 0) {
+ // handle down removal
+
+ maxX = fromX + (oldViewDistance * right) + right; // exclusive
+ minX = fromX - (oldViewDistance * right); // inclusive
+ maxZ = toZ - (oldViewDistance * up); // exclusive
+ minZ = fromZ - (oldViewDistance * up); // inclusive
+
+ for (int currX = minX; currX != maxX; currX += right) {
+ for (int currZ = minZ; currZ != maxZ; currZ += up) {
+ this.removePlayerFrom(player, currX, currZ);
+ }
+ }
+ }
+ } else {
+ // different view distance
+ // for now :)
+ this.removePlayer(player, oldPosition, oldViewDistance);
+ this.addNewPlayer(player, newPosition, newViewDistance);
+ }
+ }
+
+ private void removePlayer(final EntityPlayer player, final SectionPosition position, final int viewDistance) {
+ final int x = position.getX();
+ final int z = position.getZ();
+
+ for (int xoff = -viewDistance; xoff <= viewDistance; ++xoff) {
+ for (int zoff = -viewDistance; zoff <= viewDistance; ++zoff) {
+ this.removePlayerFrom(player, x + xoff, z + zoff);
+ }
+ }
+ }
+
+ private void addNewPlayer(final EntityPlayer player, final SectionPosition position, final int viewDistance) {
+ final int x = position.getX();
+ final int z = position.getZ();
+
+ for (int xoff = -viewDistance; xoff <= viewDistance; ++xoff) {
+ for (int zoff = -viewDistance; zoff <= viewDistance; ++zoff) {
+ this.addPlayerTo(player, x + xoff, z + zoff);
+ }
+ }
+ }
+}
diff --git a/src/main/java/com/destroystokyo/paper/util/PooledHashSets.java b/src/main/java/com/destroystokyo/paper/util/PooledHashSets.java
new file mode 100644
index 000000000..4f13d3ff8
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/util/PooledHashSets.java
@@ -0,0 +1,241 @@
+package com.destroystokyo.paper.util;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import it.unimi.dsi.fastutil.objects.ObjectLinkedOpenHashSet;
+import java.lang.ref.WeakReference;
+import java.util.Iterator;
+
+/** @author Spottedleaf */
+public class PooledHashSets {
+
+ // we really want to avoid that equals() check as much as possible...
+ protected final Object2ObjectOpenHashMap, PooledObjectLinkedOpenHashSet> mapPool = new Object2ObjectOpenHashMap<>(64, 0.25f);
+
+ protected void decrementReferenceCount(final PooledObjectLinkedOpenHashSet current) {
+ if (current.referenceCount == 0) {
+ throw new IllegalStateException("Cannot decrement reference count for " + current);
+ }
+ if (current.referenceCount == -1 || --current.referenceCount > 0) {
+ return;
+ }
+
+ this.mapPool.remove(current);
+ return;
+ }
+
+ public PooledObjectLinkedOpenHashSet findMapWith(final PooledObjectLinkedOpenHashSet current, final E object) {
+ final PooledObjectLinkedOpenHashSet cached = current.getAddCache(object);
+
+ if (cached != null) {
+ if (cached.referenceCount != -1) {
+ ++cached.referenceCount;
+ }
+
+ decrementReferenceCount(current);
+
+ return cached;
+ }
+
+ if (!current.add(object)) {
+ return current;
+ }
+
+ // we use get/put since we use a different key on put
+ PooledObjectLinkedOpenHashSet ret = this.mapPool.get(current);
+
+ if (ret == null) {
+ ret = new PooledObjectLinkedOpenHashSet<>(current);
+ current.remove(object);
+ this.mapPool.put(ret, ret);
+ ret.referenceCount = 1;
+ } else {
+ if (ret.referenceCount != -1) {
+ ++ret.referenceCount;
+ }
+ current.remove(object);
+ }
+
+ current.updateAddCache(object, ret);
+
+ decrementReferenceCount(current);
+ return ret;
+ }
+
+ // rets null if current.size() == 1
+ public PooledObjectLinkedOpenHashSet findMapWithout(final PooledObjectLinkedOpenHashSet current, final E object) {
+ if (current.set.size() == 1) {
+ decrementReferenceCount(current);
+ return null;
+ }
+
+ final PooledObjectLinkedOpenHashSet cached = current.getRemoveCache(object);
+
+ if (cached != null) {
+ if (cached.referenceCount != -1) {
+ ++cached.referenceCount;
+ }
+
+ decrementReferenceCount(current);
+
+ return cached;
+ }
+
+ if (!current.remove(object)) {
+ return current;
+ }
+
+ // we use get/put since we use a different key on put
+ PooledObjectLinkedOpenHashSet ret = this.mapPool.get(current);
+
+ if (ret == null) {
+ ret = new PooledObjectLinkedOpenHashSet<>(current);
+ current.add(object);
+ this.mapPool.put(ret, ret);
+ ret.referenceCount = 1;
+ } else {
+ if (ret.referenceCount != -1) {
+ ++ret.referenceCount;
+ }
+ current.add(object);
+ }
+
+ current.updateRemoveCache(object, ret);
+
+ decrementReferenceCount(current);
+ return ret;
+ }
+
+ public static final class PooledObjectLinkedOpenHashSet implements Iterable {
+
+ private static final WeakReference NULL_REFERENCE = new WeakReference(null);
+
+ final ObjectLinkedOpenHashSet set;
+ int referenceCount; // -1 if special
+ int hash; // optimize hashcode
+
+ // add cache
+ WeakReference lastAddObject = NULL_REFERENCE;
+ WeakReference> lastAddMap = NULL_REFERENCE;
+
+ // remove cache
+ WeakReference lastRemoveObject = NULL_REFERENCE;
+ WeakReference> lastRemoveMap = NULL_REFERENCE;
+
+ public PooledObjectLinkedOpenHashSet() {
+ this.set = new ObjectLinkedOpenHashSet<>(2, 0.6f);
+ }
+
+ public PooledObjectLinkedOpenHashSet(final E single) {
+ this();
+ this.referenceCount = -1;
+ this.add(single);
+ }
+
+ public PooledObjectLinkedOpenHashSet(final PooledObjectLinkedOpenHashSet other) {
+ this.set = other.set.clone();
+ this.hash = other.hash;
+ }
+
+ // from https://github.com/Spottedleaf/ConcurrentUtil/blob/master/src/main/java/ca/spottedleaf/concurrentutil/util/IntegerUtil.java
+ // generated by https://github.com/skeeto/hash-prospector
+ static int hash0(int x) {
+ x *= 0x36935555;
+ x ^= x >>> 16;
+ return x;
+ }
+
+ public PooledObjectLinkedOpenHashSet getAddCache(final E element) {
+ final E currentAdd = this.lastAddObject.get();
+
+ if (currentAdd == null || !(currentAdd == element || currentAdd.equals(element))) {
+ return null;
+ }
+
+ final PooledObjectLinkedOpenHashSet map = this.lastAddMap.get();
+ if (map == null || map.referenceCount == 0) {
+ // we need to ret null if ref count is zero as calling code will assume the map is in use
+ return null;
+ }
+
+ return map;
+ }
+
+ public PooledObjectLinkedOpenHashSet getRemoveCache(final E element) {
+ final E currentRemove = this.lastRemoveObject.get();
+
+ if (currentRemove == null || !(currentRemove == element || currentRemove.equals(element))) {
+ return null;
+ }
+
+ final PooledObjectLinkedOpenHashSet map = this.lastRemoveMap.get();
+ if (map == null || map.referenceCount == 0) {
+ // we need to ret null if ref count is zero as calling code will assume the map is in use
+ return null;
+ }
+
+ return map;
+ }
+
+ public void updateAddCache(final E element, final PooledObjectLinkedOpenHashSet map) {
+ this.lastAddObject = new WeakReference<>(element);
+ this.lastAddMap = new WeakReference<>(map);
+ }
+
+ public void updateRemoveCache(final E element, final PooledObjectLinkedOpenHashSet map) {
+ this.lastRemoveObject = new WeakReference<>(element);
+ this.lastRemoveMap = new WeakReference<>(map);
+ }
+
+ boolean add(final E element) {
+ boolean added = this.set.add(element);
+
+ if (added) {
+ this.hash += hash0(element.hashCode());
+ }
+
+ return added;
+ }
+
+ boolean remove(Object element) {
+ boolean removed = this.set.remove(element);
+
+ if (removed) {
+ this.hash -= hash0(element.hashCode());
+ }
+
+ return removed;
+ }
+
+ @Override
+ public Iterator iterator() {
+ return this.set.iterator();
+ }
+
+ @Override
+ public int hashCode() {
+ return this.hash;
+ }
+
+ @Override
+ public boolean equals(final Object other) {
+ if (!(other instanceof PooledObjectLinkedOpenHashSet)) {
+ return false;
+ }
+ if (this.referenceCount == 0) {
+ return other == this;
+ } else {
+ if (other == this) {
+ // Unfortunately we are never equal to our own instance while in use!
+ return false;
+ }
+ return this.hash == ((PooledObjectLinkedOpenHashSet)other).hash && this.set.equals(((PooledObjectLinkedOpenHashSet)other).set);
+ }
+ }
+
+ @Override
+ public String toString() {
+ return "PooledHashSet: size: " + this.set.size() + ", reference count: " + this.referenceCount + ", hash: " +
+ this.hashCode() + ", identity: " + System.identityHashCode(this) + " map: " + this.set.toString();
+ }
+ }
+}
diff --git a/src/main/java/com/destroystokyo/paper/util/PriorityQueuedExecutor.java b/src/main/java/com/destroystokyo/paper/util/PriorityQueuedExecutor.java
deleted file mode 100644
index 8f18c2869..000000000
--- a/src/main/java/com/destroystokyo/paper/util/PriorityQueuedExecutor.java
+++ /dev/null
@@ -1,347 +0,0 @@
-package com.destroystokyo.paper.util;
-
-import javax.annotation.Nonnull;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.AbstractExecutorService;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.RejectedExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.function.Supplier;
-
-/**
- * Implements an Executor Service that allows specifying Task Priority
- * and bumping of task priority.
- *
- * This is a non blocking executor with 3 priority levels.
- *
- * URGENT: Rarely used, something that is critical to take action now.
- * HIGH: Something with more importance than the base tasks
- *
- * @author Daniel Ennis <aikar@aikar.co>
- */
-@SuppressWarnings({"WeakerAccess", "UnusedReturnValue", "unused"})
-public class PriorityQueuedExecutor extends AbstractExecutorService {
-
- private final ConcurrentLinkedQueue urgent = new ConcurrentLinkedQueue<>();
- private final ConcurrentLinkedQueue high = new ConcurrentLinkedQueue<>();
- private final ConcurrentLinkedQueue normal = new ConcurrentLinkedQueue<>();
- private final List threads = new ArrayList<>();
- private final RejectionHandler handler;
-
- private volatile boolean shuttingDown = false;
- private volatile boolean shuttingDownNow = false;
-
- public PriorityQueuedExecutor(String name) {
- this(name, Math.max(1, Runtime.getRuntime().availableProcessors() - 1));
- }
-
- public PriorityQueuedExecutor(String name, int threads) {
- this(name, threads, Thread.NORM_PRIORITY, null);
- }
-
- public PriorityQueuedExecutor(String name, int threads, int threadPriority) {
- this(name, threads, threadPriority, null);
- }
-
- public PriorityQueuedExecutor(String name, int threads, RejectionHandler handler) {
- this(name, threads, Thread.NORM_PRIORITY, handler);
- }
-
- public PriorityQueuedExecutor(String name, int threads, int threadPriority, RejectionHandler handler) {
- for (int i = 0; i < threads; i++) {
- ExecutorThread thread = new ExecutorThread(this::processQueues);
- thread.setDaemon(true);
- thread.setName(threads == 1 ? name : name + "-" + (i + 1));
- thread.setPriority(threadPriority);
- thread.start();
- this.threads.add(thread);
- }
- if (handler == null) {
- handler = ABORT_POLICY;
- }
- this.handler = handler;
- }
-
- /**
- * If the Current thread belongs to a PriorityQueuedExecutor, return that Executro
- * @return The executor that controls this thread
- */
- public static PriorityQueuedExecutor getExecutor() {
- if (!(Thread.currentThread() instanceof ExecutorThread)) {
- return null;
- }
- return ((ExecutorThread) Thread.currentThread()).getExecutor();
- }
-
- public void shutdown() {
- shuttingDown = true;
- synchronized (this) {
- this.notifyAll();
- }
- }
-
- @Nonnull
- @Override
- public List shutdownNow() {
- shuttingDown = true;
- shuttingDownNow = true;
- List tasks = new ArrayList<>(high.size() + normal.size());
- Runnable run;
- while ((run = getTask()) != null) {
- tasks.add(run);
- }
-
- return tasks;
- }
-
- @Override
- public boolean isShutdown() {
- return shuttingDown;
- }
-
- @Override
- public boolean isTerminated() {
- if (!shuttingDown) {
- return false;
- }
- return high.isEmpty() && normal.isEmpty();
- }
-
- @Override
- public boolean awaitTermination(long timeout, @Nonnull TimeUnit unit) {
- synchronized (this) {
- this.notifyAll();
- }
- final long wait = unit.toNanos(timeout);
- final long max = System.nanoTime() + wait;
- for (;!threads.isEmpty() && System.nanoTime() < max;) {
- threads.removeIf(thread -> !thread.isAlive());
- }
- return isTerminated();
- }
-
-
- public PendingTask createPendingTask(Runnable task) {
- return createPendingTask(task, Priority.NORMAL);
- }
- public PendingTask createPendingTask(Runnable task, Priority priority) {
- return createPendingTask(() -> {
- task.run();
- return null;
- }, priority);
- }
-
- public PendingTask createPendingTask(Supplier task) {
- return createPendingTask(task, Priority.NORMAL);
- }
-
- public PendingTask createPendingTask(Supplier task, Priority priority) {
- return new PendingTask<>(task, priority);
- }
-
- public PendingTask submitTask(Runnable run) {
- return createPendingTask(run).submit();
- }
-
- public PendingTask submitTask(Runnable run, Priority priority) {
- return createPendingTask(run, priority).submit();
- }
-
- public PendingTask submitTask(Supplier run) {
- return createPendingTask(run).submit();
- }
-
- public PendingTask submitTask(Supplier run, Priority priority) {
- PendingTask task = createPendingTask(run, priority);
- return task.submit();
- }
-
- @Override
- public void execute(@Nonnull Runnable command) {
- submitTask(command);
- }
-
- public boolean isCurrentThread() {
- final Thread thread = Thread.currentThread();
- if (!(thread instanceof ExecutorThread)) {
- return false;
- }
- return ((ExecutorThread) thread).getExecutor() == this;
- }
-
- public Runnable getUrgentTask() {
- return urgent.poll();
- }
-
- public Runnable getTask() {
- Runnable run = urgent.poll();
- if (run != null) {
- return run;
- }
- run = high.poll();
- if (run != null) {
- return run;
- }
- return normal.poll();
- }
-
- private void processQueues() {
- Runnable run = null;
- while (true) {
- if (run != null) {
- run.run();
- }
- if (shuttingDownNow) {
- return;
- }
- if ((run = getTask()) != null) {
- continue;
- }
- synchronized (PriorityQueuedExecutor.this) {
- if ((run = getTask()) != null) {
- continue;
- }
-
- if (shuttingDown || shuttingDownNow) {
- return;
- }
- try {
- PriorityQueuedExecutor.this.wait();
- } catch (InterruptedException ignored) {
- }
- }
- }
- }
-
- public boolean processUrgentTasks() {
- Runnable run;
- boolean hadTask = false;
- while ((run = getUrgentTask()) != null) {
- run.run();
- hadTask = true;
- }
- return hadTask;
- }
-
- public enum Priority {
- NORMAL, HIGH, URGENT
- }
-
- public class ExecutorThread extends Thread {
- public ExecutorThread(Runnable runnable) {
- super(runnable);
- }
-
- public PriorityQueuedExecutor getExecutor() {
- return PriorityQueuedExecutor.this;
- }
- }
-
- public class PendingTask implements Runnable {
-
- private final AtomicBoolean hasRan = new AtomicBoolean();
- private final AtomicInteger submitted = new AtomicInteger(-1);
- private final AtomicInteger priority;
- private final Supplier run;
- private final CompletableFuture future = new CompletableFuture<>();
- private volatile PriorityQueuedExecutor executor;
-
- public PendingTask(Supplier run) {
- this(run, Priority.NORMAL);
- }
-
- public PendingTask(Supplier run, Priority priority) {
- this.priority = new AtomicInteger(priority.ordinal());
- this.run = run;
- }
-
- public boolean cancel() {
- return hasRan.compareAndSet(false, true);
- }
-
- @Override
- public void run() {
- if (!hasRan.compareAndSet(false, true)) {
- return;
- }
-
- try {
- future.complete(run.get());
- } catch (Throwable e) {
- future.completeExceptionally(e);
- }
- }
-
- public void bumpPriority() {
- bumpPriority(Priority.HIGH);
- }
-
- public void bumpPriority(Priority newPriority) {
- for (;;) {
- int current = this.priority.get();
- int ordinal = newPriority.ordinal();
- if (current >= ordinal || priority.compareAndSet(current, ordinal)) {
- break;
- }
- }
-
-
- if (this.submitted.get() == -1 || this.hasRan.get()) {
- return;
- }
-
- // Only resubmit if it hasnt ran yet and has been submitted
- submit();
- }
-
- public CompletableFuture onDone() {
- return future;
- }
-
- public PendingTask submit() {
- if (shuttingDown) {
- handler.onRejection(this, PriorityQueuedExecutor.this);
- return this;
- }
- for (;;) {
- final int submitted = this.submitted.get();
- final int priority = this.priority.get();
- if (submitted == priority) {
- return this;
- }
- if (this.submitted.compareAndSet(submitted, priority)) {
- if (priority == Priority.URGENT.ordinal()) {
- urgent.add(this);
- } else if (priority == Priority.HIGH.ordinal()) {
- high.add(this);
- } else {
- normal.add(this);
- }
-
- break;
- }
- }
-
- synchronized (PriorityQueuedExecutor.this) {
- // Wake up a thread to take this work
- PriorityQueuedExecutor.this.notify();
- }
- return this;
- }
- }
- public interface RejectionHandler {
- void onRejection(Runnable run, PriorityQueuedExecutor executor);
- }
-
- public static final RejectionHandler ABORT_POLICY = (run, executor) -> {
- throw new RejectedExecutionException("Executor has been shutdown");
- };
- public static final RejectionHandler CALLER_RUNS_POLICY = (run, executor) -> {
- run.run();
- };
-
-}
diff --git a/src/main/java/com/destroystokyo/paper/util/RedstoneWireTurbo.java b/src/main/java/com/destroystokyo/paper/util/RedstoneWireTurbo.java
index 4b3d62ab8..cf5661f1c 100644
--- a/src/main/java/com/destroystokyo/paper/util/RedstoneWireTurbo.java
+++ b/src/main/java/com/destroystokyo/paper/util/RedstoneWireTurbo.java
@@ -13,6 +13,8 @@ import net.minecraft.server.Block;
import net.minecraft.server.BlockPosition;
import net.minecraft.server.BlockRedstoneWire;
import net.minecraft.server.IBlockData;
+import net.minecraft.server.Items;
+import net.minecraft.server.ItemStack;
import net.minecraft.server.World;
/**
@@ -320,7 +322,7 @@ public class RedstoneWireTurbo {
// be replicated here.
if (!wire.canPlace(null, worldIn, pos)) {
// Pop off the redstone dust
- oldState.dropNaturally(worldIn, pos, 0);
+ Block.a(worldIn, pos, new ItemStack(Items.REDSTONE)); // TODO
worldIn.setAir(pos);
// Mark this position as not being redstone wire
@@ -843,7 +845,7 @@ public class RedstoneWireTurbo {
// position directly above the node being calculated is always
// at index 1.
UpdateNode center_up = upd.neighbor_nodes[1];
- boolean center_up_is_cube = center_up.currentState.isOccluding();
+ boolean center_up_is_cube = center_up.currentState.isOccluding(worldIn, center_up.self); // TODO
for (int m = 0; m < 4; m++) {
// Get the neighbor array index of each of the four cardinal
@@ -857,7 +859,7 @@ public class RedstoneWireTurbo {
// Also check the positions above and below the cardinal
// neighbors
- boolean neighbor_is_cube = neighbor.currentState.isOccluding();
+ boolean neighbor_is_cube = neighbor.currentState.isOccluding(worldIn, neighbor.self); // TODO
if (!neighbor_is_cube) {
UpdateNode neighbor_down = upd.neighbor_nodes[rs_neighbors_dn[m]];
l = getMaxCurrentStrength(neighbor_down, l);
@@ -881,7 +883,7 @@ public class RedstoneWireTurbo {
// egg82's amendment
// Adding Bukkit's BlockRedstoneEvent - er.. event.
if (i != j) {
- BlockRedstoneEvent event = new BlockRedstoneEvent(worldIn.getWorld().getBlockAt(upd.self), i, j); // Akarin
+ BlockRedstoneEvent event = new BlockRedstoneEvent(worldIn.getWorld().getBlockAt(upd.self.getX(), upd.self.getY(), upd.self.getZ()), i, j);
worldIn.getServer().getPluginManager().callEvent(event);
j = event.getNewCurrent();
}
diff --git a/src/main/java/com/destroystokyo/paper/util/ReentrantLockWithGetOwner.java b/src/main/java/com/destroystokyo/paper/util/ReentrantLockWithGetOwner.java
new file mode 100644
index 000000000..a3b174618
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/util/ReentrantLockWithGetOwner.java
@@ -0,0 +1,11 @@
+package com.destroystokyo.paper.util;
+
+import java.util.concurrent.locks.ReentrantLock;
+
+public class ReentrantLockWithGetOwner extends ReentrantLock {
+
+ @Override
+ public Thread getOwner() {
+ return super.getOwner();
+ }
+}
diff --git a/src/main/java/com/mojang/authlib/yggdrasil/YggdrasilGameProfileRepository.java b/src/main/java/com/mojang/authlib/yggdrasil/YggdrasilGameProfileRepository.java
index 370c8716d..23f1447cf 100644
--- a/src/main/java/com/mojang/authlib/yggdrasil/YggdrasilGameProfileRepository.java
+++ b/src/main/java/com/mojang/authlib/yggdrasil/YggdrasilGameProfileRepository.java
@@ -18,10 +18,7 @@ import java.util.Set;
public class YggdrasilGameProfileRepository implements GameProfileRepository {
private static final Logger LOGGER = LogManager.getLogger();
- // Akarin Start
- //private static final String BASE_URL = "https://api.mojang.com/";
- private static final String BASE_URL = io.akarin.server.core.AkarinGlobalConfig.yggdrasilServerURL; //Akarin
- // Akarin End
+ private static final String BASE_URL = "https://api.mojang.com/";
private static final String SEARCH_PAGE_URL = BASE_URL + "profiles/";
private static final int ENTRIES_PER_PAGE = 2;
private static final int MAX_FAIL_COUNT = 3;
diff --git a/src/main/java/io/akarin/server/api/structure/CraftVillage.java b/src/main/java/io/akarin/server/api/structure/CraftVillage.java
deleted file mode 100644
index 121e77e28..000000000
--- a/src/main/java/io/akarin/server/api/structure/CraftVillage.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package io.akarin.server.api.structure;
-
-import lombok.RequiredArgsConstructor;
-
-@RequiredArgsConstructor
-public class CraftVillage implements Village {
- private final net.minecraft.server.Village village;
-
- public Village getHandle() {
- return (Village) village;
- }
-
- @Override
- public String toString() {
- return "CraftVillage";
- }
-}
diff --git a/src/main/java/io/akarin/server/core/AkarinAsyncExecutor.java b/src/main/java/io/akarin/server/core/AkarinAsyncExecutor.java
deleted file mode 100644
index 386919e27..000000000
--- a/src/main/java/io/akarin/server/core/AkarinAsyncExecutor.java
+++ /dev/null
@@ -1,61 +0,0 @@
-package io.akarin.server.core;
-
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
-
-import co.aikar.timings.ThreadAssertion;
-
-public class AkarinAsyncExecutor {
- private static final ExecutorService singleExecutor = Executors.newSingleThreadExecutor(new ThreadFactoryBuilder().setNameFormat("Akarin Single Async Executor Thread - %1$d").build());
- private static final ExecutorService asyncExecutor = Executors.newFixedThreadPool(getNThreads(), new ThreadFactoryBuilder().setNameFormat("Akarin Async Executor Thread - %1$d").build());
-
- private static int getNThreads() {
- int processors = Runtime.getRuntime().availableProcessors() / 2;
- if (processors < 2)
- return 2;
- if (processors > 8)
- return 8;
- return processors;
- }
-
- /**
- * Posts a task to be executed asynchronously in a single thread
- * @param run
- */
- public static void scheduleSingleAsyncTask(Runnable run) {
- ThreadAssertion.close();
- singleExecutor.execute(run);
- }
-
- /**
- * Posts a task to be executed asynchronously
- * @param run
- */
- public static void scheduleAsyncTask(Runnable run) {
- ThreadAssertion.close();
- asyncExecutor.execute(run);
- }
-
- /**
- * Posts a task to be executed asynchronously in a single thread
- * @param run
- * @return
- */
- public static Future scheduleSingleAsyncTask(Callable run) {
- ThreadAssertion.close();
- return singleExecutor.submit(run);
- }
-
- /**
- * Posts a task to be executed asynchronously
- * @param run
- */
- public static Future scheduleAsyncTask(Callable run) {
- ThreadAssertion.close();
- return asyncExecutor.submit(run);
- }
-}
\ No newline at end of file
diff --git a/src/main/java/io/akarin/server/core/AkarinAsyncScheduler.java b/src/main/java/io/akarin/server/core/AkarinAsyncScheduler.java
deleted file mode 100644
index 253eb85e3..000000000
--- a/src/main/java/io/akarin/server/core/AkarinAsyncScheduler.java
+++ /dev/null
@@ -1,129 +0,0 @@
-package io.akarin.server.core;
-
-import java.util.List;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
-import com.google.common.base.Predicate;
-import com.google.common.collect.Iterables;
-
-import net.minecraft.server.EntityHuman;
-import net.minecraft.server.EntityPlayer;
-import net.minecraft.server.EnumDifficulty;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.NetworkManager;
-import net.minecraft.server.PacketPlayOutPlayerInfo;
-import net.minecraft.server.PacketPlayOutUpdateTime;
-import net.minecraft.server.WorldServer;
-
-public class AkarinAsyncScheduler extends Thread {
- private final static Logger LOGGER = LogManager.getLogger("Akarin");
- private final static int STD_TICK_TIME = 50;
-
- public static AkarinAsyncScheduler initalise() {
- return Singleton.instance;
- }
-
- private static class Singleton {
- private static final AkarinAsyncScheduler instance;
-
- static {
- instance = new AkarinAsyncScheduler();
- instance.setName("Akarin Async Scheduler Thread");
- instance.setDaemon(true);
- instance.setPriority(MIN_PRIORITY);
- instance.start();
- LOGGER.info("Async executor started");
- }
- }
-
- private int playerListTick;
-
- @Override
- public void run() {
- MinecraftServer server = MinecraftServer.getServer();
-
- while (server.isRunning()) {
- long currentLoop = System.currentTimeMillis();
-
- // Send pending chunk packets
- List networkManagers = server.getServerConnection().getNetworkManagers();
- if (!networkManagers.isEmpty()) {
- synchronized (networkManagers) {
- for (NetworkManager player : networkManagers)
- player.sendPacketQueue();
- }
- }
-
- for (WorldServer world : server.getWorlds()) {
- // Send time updates to everyone, it will get the right time from the world the player is in.
- boolean doDaylight = world.getGameRules().getBoolean("doDaylightCycle");
- long dayTime = world.getDayTime();
- long worldTime = world.getTime();
- final PacketPlayOutUpdateTime worldPacket = new PacketPlayOutUpdateTime(worldTime, dayTime, doDaylight);
- for (EntityHuman entityhuman : world.players) {
- if (!(entityhuman instanceof EntityPlayer) || (server.currentTick() + entityhuman.getId()) % 20 != 0) {
- continue;
- }
- EntityPlayer entityplayer = (EntityPlayer) entityhuman;
- long playerTime = entityplayer.getPlayerTime();
- PacketPlayOutUpdateTime packet = (playerTime == dayTime) ? worldPacket :
- new PacketPlayOutUpdateTime(worldTime, playerTime, doDaylight);
- entityplayer.playerConnection.sendPacket(packet); // Add support for per player time
- }
-
- // Hardcore difficulty lock
- if (world.getWorldData().isHardcore() && world.getDifficulty() != EnumDifficulty.HARD) {
- world.getWorldData().setDifficulty(EnumDifficulty.HARD);
- }
-
- // Sleeping time management
- if (world.everyoneDeeplySleeping()) {
- if (world.getGameRules().getBoolean("doDaylightCycle")) {
- long i = world.worldData.getDayTime() + 24000L;
-
- world.worldData.setDayTime(i - i % 24000L);
- }
-
- if (world.getGameRules().getBoolean("doWeatherCycle")) {
- world.clearWeather();
- }
- }
-
- // Random light updates
- world.randomLightUpdates();
- }
-
- // Send player latency update packets
- if (++playerListTick > 600) {
- List players = server.getPlayerList().players;
- for (EntityPlayer target : players) {
- target.playerConnection.sendPacket(new PacketPlayOutPlayerInfo(PacketPlayOutPlayerInfo.EnumPlayerInfoAction.UPDATE_LATENCY, Iterables.filter(players, new Predicate() {
- @Override
- public boolean apply(EntityPlayer input) {
- return target.getBukkitEntity().canSee(input.getBukkitEntity());
- }
- })));
- }
- playerListTick = 0;
- }
-
- // Save players data
- int playerSaveInterval = com.destroystokyo.paper.PaperConfig.playerAutoSaveRate;
- if (playerSaveInterval < 0) {
- playerSaveInterval = server.autosavePeriod;
- }
- if (playerSaveInterval > 0) {
- server.getPlayerList().savePlayers(playerSaveInterval);
- }
-
- try {
- long sleepFixed = STD_TICK_TIME - (System.currentTimeMillis() - currentLoop);
- if (sleepFixed > 0) Thread.sleep(sleepFixed);
- } catch (InterruptedException interrupted) {
- continue;
- }
- }
- }
-}
\ No newline at end of file
diff --git a/src/main/java/io/akarin/server/core/AkarinCreatureSpanwner.java b/src/main/java/io/akarin/server/core/AkarinCreatureSpanwner.java
deleted file mode 100644
index c2acc5554..000000000
--- a/src/main/java/io/akarin/server/core/AkarinCreatureSpanwner.java
+++ /dev/null
@@ -1,275 +0,0 @@
-package io.akarin.server.core;
-
-import java.util.EnumMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Random;
-import java.util.Set;
-import java.util.concurrent.ThreadLocalRandom;
-
-import javax.annotation.Nullable;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason;
-
-import com.destroystokyo.paper.event.entity.PlayerNaturallySpawnCreaturesEvent;
-import com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent;
-import com.destroystokyo.paper.exception.ServerInternalException;
-import com.google.common.collect.Maps;
-import com.koloboke.collect.set.hash.HashObjSets;
-
-import io.akarin.server.misc.ChunkCoordOrdinalInt3Tuple;
-import net.minecraft.server.BiomeBase;
-import net.minecraft.server.BlockPosition;
-import net.minecraft.server.ChunkCoordIntPair;
-import net.minecraft.server.EntityHuman;
-import net.minecraft.server.EntityInsentient;
-import net.minecraft.server.EntityPositionTypes;
-import net.minecraft.server.EntityTypes;
-import net.minecraft.server.EnumCreatureType;
-import net.minecraft.server.GroupDataEntity;
-import net.minecraft.server.MCUtil;
-import net.minecraft.server.MathHelper;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.SpawnerCreature;
-import net.minecraft.server.WorldServer;
-
-/*
- * Reference on spawning mechanics by Colin Godsey
- * https://github.com/yesdog/Paper/blob/0de3dd84b7e6688feb42af4fe6b4f323ce7e3013/Spigot-Server-Patches/0433-alternate-mob-spawning-mechanic.patch
- */
-public class AkarinCreatureSpanwner {
- private static final Map rangeChunks = Maps.newConcurrentMap();
-
- public static void increment(ChunkCoordIntPair chunk, EnumCreatureType type) {
- int[] values = rangeChunks.get(chunk);
- if (values == null) {
- values = new int[EnumCreatureType.values().length];;
- values[type.ordinal()]++;
- rangeChunks.put(chunk, values);
- } else {
- values[type.ordinal()]++;
- }
- }
-
- public static void decrement(ChunkCoordIntPair chunk, EnumCreatureType type) {
- int[] values = rangeChunks.get(chunk);
- if (values == null) {
- values = new int[EnumCreatureType.values().length];;
- int count = values[type.ordinal()];
- values[type.ordinal()] = count > 1 ? --count : 0;
- rangeChunks.put(chunk, values);
- } else {
- int count = values[type.ordinal()];
- values[type.ordinal()] = count > 1 ? --count : 0;
- }
- }
-
- private static int getSpawnRange(WorldServer world, EntityHuman player) {
- byte mobSpawnRange = world.spigotConfig.mobSpawnRange;
-
- mobSpawnRange = (mobSpawnRange > world.spigotConfig.viewDistance) ? (byte) world.spigotConfig.viewDistance : mobSpawnRange;
- mobSpawnRange = (mobSpawnRange > 8) ? 8 : mobSpawnRange;
-
- if (PlayerNaturallySpawnCreaturesEvent.getHandlerList().getRegisteredListeners().length != 0) {
- PlayerNaturallySpawnCreaturesEvent event = new PlayerNaturallySpawnCreaturesEvent((Player) player.getBukkitEntity(), mobSpawnRange);
- // prevent concurrent handling, at least
- synchronized (PlayerNaturallySpawnCreaturesEvent.class) {
- Bukkit.getPluginManager().callEvent(event);
- }
-
- return event.isCancelled() ? 0 : event.getSpawnRadius();
- }
-
- return mobSpawnRange;
- }
-
- private static int getCreatureLimit(WorldServer world, EnumCreatureType type) {
- switch (type) {
- case MONSTER:
- return world.getWorld().getMonsterSpawnLimit();
- case CREATURE:
- return world.getWorld().getAnimalSpawnLimit();
- case WATER_CREATURE:
- return world.getWorld().getWaterAnimalSpawnLimit();
- case AMBIENT:
- return world.getWorld().getAmbientSpawnLimit();
- }
- return type.spawnLimit();
- }
-
- @Nullable
- private static EntityInsentient createMob(WorldServer world, EnumCreatureType type, BlockPosition pos, BiomeBase.BiomeMeta biomeMeta) {
- if (!world.isBiomeMetaValidAt(type, biomeMeta, pos)) return null;
-
- EntityTypes entityType = biomeMeta.entityType();
- org.bukkit.entity.EntityType bType = EntityTypes.clsToTypeMap.get(entityType.entityClass());
- if (bType != null) {
- PreCreatureSpawnEvent event = new PreCreatureSpawnEvent(
- MCUtil.toLocation(world, pos),
- bType, SpawnReason.NATURAL
- );
-
- if (!event.callEvent() || event.shouldAbortSpawn())
- return null;
- }
-
- EntityInsentient entity = null;
-
- try {
- entity = entityType.create(world);
- } catch (Exception exception) {
- MinecraftServer.LOGGER.warn("Failed to create mob", exception);
- ServerInternalException.reportInternalException(exception);
- }
-
- return entity;
- }
-
- private static void spawnMob0(WorldServer world, Set chunks, EnumCreatureType type, int amount) {
- if (chunks.isEmpty()) return;
-
- Random rand = ThreadLocalRandom.current();
- final int maxPackIterations = 10; // X attempts per pack, 1 pack per chunk
- Iterator iterator = chunks.iterator();
- BlockPosition worldSpawn = world.getSpawn();
-
- int spawned = 0;
-
- while (spawned < amount && iterator.hasNext()) {
- ChunkCoordIntPair chunkCoord = iterator.next();
- int packSize = rand.nextInt(4) + 1;
- BlockPosition packCenter = SpawnerCreature.getRandomPosition(world, chunkCoord.x, chunkCoord.z);
-
- if (world.getType(packCenter).isOccluding()) continue;
-
- int x = packCenter.getX();
- int y = packCenter.getY();
- int z = packCenter.getZ();
- BlockPosition.MutableBlockPosition blockPointer = new BlockPosition.MutableBlockPosition();
- BiomeBase.BiomeMeta biomeMeta = null;
- GroupDataEntity group = null;
- EntityPositionTypes.Surface surfaceType = null;
- int iter = 0;
- int packSpawned = 0;
-
- while (packSpawned < packSize && iter < maxPackIterations) {
- iter++;
-
- // random walk
- x += rand.nextInt(12) - 6;
- y += rand.nextInt(2) - 1;
- z += rand.nextInt(12) - 6;
- blockPointer.setValues(x, y, z);
-
- if (worldSpawn.distanceSquared(x + 0.5, y, z + 0.5) < (24 * 24)) continue;
-
- if (biomeMeta == null) {
- biomeMeta = world.getBiomeMetaAt(type, blockPointer);
-
- if (biomeMeta == null) break;
-
- int packRange = 1 + biomeMeta.getMaxPackSize() - biomeMeta.getMinPackSize();
- packSize = biomeMeta.getMinPackSize() + rand.nextInt(packRange);
- surfaceType = EntityPositionTypes.a(biomeMeta.entityType());
- }
-
- EntityInsentient entity = createMob(world, type, blockPointer, biomeMeta);
-
- if (entity == null) continue;
-
- entity.setPositionRotation(x + 0.5, y, z + 0.5, rand.nextFloat() * 360.0F, 0.0F);
-
- if (entity.canSpawnHere() && surfaceType != null
- && SpawnerCreature.isValidSpawnSurface(surfaceType, world, blockPointer, biomeMeta.entityType())
- && entity.isNotColliding(world) && !world.isPlayerNearby(x + 0.5, y, z + 0.5, 24)) {
- group = entity.prepare(world.getDamageScaler(new BlockPosition(entity)), group, null);
-
- if (entity.isNotColliding(world) && world.addEntity(entity, SpawnReason.NATURAL))
- packSpawned++;
-
- if (packSpawned >= entity.maxPackSize()) break;
- if ((packSpawned + spawned) >= amount) break;
- } else {
- entity.die();
- }
- }
-
- spawned += packSpawned;
- }
- }
-
- public static void spawnMobs(WorldServer world, boolean spawnMonsters, boolean spawnPassives, boolean spawnRare) {
- if(!spawnMonsters && !spawnPassives) return;
-
- AkarinAsyncExecutor.scheduleAsyncTask(() -> {
- Random rand = ThreadLocalRandom.current();
- int hashOrdinal = rand.nextInt();
-
- //Set rangeChunks = HashObjSets.newUpdatableSet();
- Map> creatureChunks = new EnumMap<>(EnumCreatureType.class);
- int[] typeNumSpawn = new int[EnumCreatureType.values().length];
-
- for (EnumCreatureType type : EnumCreatureType.values()) {
- if (type.passive() && !spawnPassives) continue;
- if (!type.passive() && !spawnMonsters) continue;
- if (type.rare() && !spawnRare) continue;
- if (getCreatureLimit(world, type) <= 0) continue;
-
- creatureChunks.put(type, HashObjSets.newUpdatableSet());
- }
-
- if (creatureChunks.isEmpty()) return;
-
- for (EntityHuman player : world.players) {
- if (!player.affectsSpawning || player.isSpectator()) continue;
-
- int spawnRange = getSpawnRange(world, player);
- if (spawnRange <= 0) continue;
-
- int playerChunkX = MathHelper.floor(player.locX / 16.0);
- int playerChunkZ = MathHelper.floor(player.locZ / 16.0);
-
- rangeChunks.clear();
-
- for (int dX = -spawnRange; dX <= spawnRange; ++dX) {
- for (int dZ = -spawnRange; dZ <= spawnRange; ++dZ) {
- ChunkCoordIntPair chunkCoord = new ChunkCoordOrdinalInt3Tuple(dX + playerChunkX, dZ + playerChunkZ, hashOrdinal);
-
- if (!world.getWorldBorder().isInBounds(chunkCoord)) continue;
-
- ChunkCoordIntPair pair = new ChunkCoordIntPair(chunkCoord.x, chunkCoord.z);
- int[] cached = rangeChunks.get(pair);
- if (cached == null)
- rangeChunks.put(pair, new int[EnumCreatureType.values().length]);
- else
- for (int i = 0; i < cached.length; i++)
- cached[i] = 0;
- }
- }
-
- for (EnumCreatureType type : creatureChunks.keySet()) {
- int limit = getCreatureLimit(world, type);
- int creatureTotal = 0;
-
- for (int[] chunk : rangeChunks.values())
- creatureTotal += chunk[type.ordinal()];
-
- // if our local count is above the limit, dont qualify our chunks
- if (creatureTotal >= limit) continue;
-
- // expect number is rather meaningless, just a ceil
- int expect = limit - creatureTotal;
- typeNumSpawn[type.ordinal()] = Math.max(typeNumSpawn[type.ordinal()], expect);
- }
- }
-
- for (EnumCreatureType type : creatureChunks.keySet()) {
- Set chunks = creatureChunks.get(type);
-
- if (!chunks.isEmpty())
- MinecraftServer.getServer().ensuresMainThread(() -> spawnMob0(world, chunks, type, typeNumSpawn[type.ordinal()]));
- }
- });
- }
-}
\ No newline at end of file
diff --git a/src/main/java/io/akarin/server/core/AkarinWorldAccessor.java b/src/main/java/io/akarin/server/core/AkarinWorldAccessor.java
deleted file mode 100644
index a0350329a..000000000
--- a/src/main/java/io/akarin/server/core/AkarinWorldAccessor.java
+++ /dev/null
@@ -1,146 +0,0 @@
-package io.akarin.server.core;
-
-import java.util.List;
-
-import javax.annotation.Nullable;
-
-import com.google.common.collect.Lists;
-
-import net.minecraft.server.BlockPosition;
-import net.minecraft.server.Entity;
-import net.minecraft.server.EntityHuman;
-import net.minecraft.server.IBlockAccess;
-import net.minecraft.server.IBlockData;
-import net.minecraft.server.IWorldAccess;
-import net.minecraft.server.NavigationListener;
-import net.minecraft.server.ParticleParam;
-import net.minecraft.server.SoundCategory;
-import net.minecraft.server.SoundEffect;
-import net.minecraft.server.WorldManager;
-
-public class AkarinWorldAccessor implements IWorldAccess {
- private @Nullable WorldManager worldManager;
- private final NavigationListener navigationListener;
- private IWorldAccess[] customAccessors = new IWorldAccess[0];
- private boolean hasCustomAccessor;
-
- public AkarinWorldAccessor(WorldManager worldManager, NavigationListener navigationListener) {
- this.worldManager = worldManager;
- this.navigationListener = navigationListener;
- }
-
- public AkarinWorldAccessor(NavigationListener navigationListener) {
- this.navigationListener = navigationListener;
- }
-
- public void add(IWorldAccess worldAccessor) {
- if (worldManager == null && worldAccessor instanceof WorldManager) {
- worldManager = (WorldManager) worldAccessor;
- return;
- }
- List accessors = Lists.newArrayList(customAccessors);
- accessors.add(worldAccessor);
- customAccessors = accessors.toArray(new IWorldAccess[accessors.size()]);
- hasCustomAccessor = true;
- }
-
- @Override
- public void a(Entity arg0) {
- worldManager.a(arg0);
- navigationListener.a(arg0);
- if (hasCustomAccessor)
- for (IWorldAccess accessor : customAccessors)
- accessor.a(arg0);
- }
-
- @Override
- public void a(int arg0, BlockPosition arg1, int arg2) {
- worldManager.a(arg0, arg1, arg2);
- if (hasCustomAccessor)
- for (IWorldAccess accessor : customAccessors)
- accessor.a(arg0, arg1, arg2);
- }
-
- @Override
- public void a(EntityHuman arg0, int arg1, BlockPosition arg2, int arg3) {
- worldManager.a(arg0, arg1, arg2, arg3);
- if (hasCustomAccessor)
- for (IWorldAccess accessor : customAccessors)
- accessor.a(arg0, arg1, arg2, arg3);
- }
-
- @Override
- public void a(IBlockAccess arg0, BlockPosition arg1, IBlockData arg2, IBlockData arg3, int arg4) {
- worldManager.a(arg0, arg1, arg2, arg3, arg4);
- navigationListener.a(arg0, arg1, arg2, arg3, arg4);
- if (hasCustomAccessor)
- for (IWorldAccess accessor : customAccessors)
- accessor.a(arg0, arg1, arg2, arg3, arg4);
- }
-
- @Override
- public void a(EntityHuman arg0, SoundEffect arg1, SoundCategory arg2, double arg3, double arg4, double arg5, float arg6, float arg7) {
- worldManager.a(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
- if (hasCustomAccessor)
- for (IWorldAccess accessor : customAccessors)
- accessor.a(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
- }
-
- @Override
- public void b(Entity arg0) {
- worldManager.b(arg0);
- navigationListener.b(arg0);
- if (hasCustomAccessor)
- for (IWorldAccess accessor : customAccessors)
- accessor.b(arg0);
- }
-
- @Override
- public void b(int arg0, BlockPosition arg1, int arg2) {
- worldManager.b(arg0, arg1, arg2);
- if (hasCustomAccessor)
- for (IWorldAccess accessor : customAccessors)
- accessor.b(arg0, arg1, arg2);
- }
-
- // unused
- @Override
- @Deprecated
- public void a(BlockPosition arg0) {
- if (hasCustomAccessor)
- for (IWorldAccess accessor : customAccessors)
- accessor.a(arg0);
- }
-
- @Override
- @Deprecated
- public void a(SoundEffect arg0, BlockPosition arg1) {
- if (hasCustomAccessor)
- for (IWorldAccess accessor : customAccessors)
- accessor.a(arg0, arg1);
- }
-
- @Override
- @Deprecated
- public void a(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5) {
- if (hasCustomAccessor)
- for (IWorldAccess accessor : customAccessors)
- accessor.a(arg0, arg1, arg2, arg3, arg4, arg5);
- }
-
- @Override
- @Deprecated
- public void a(ParticleParam arg0, boolean arg1, double arg2, double arg3, double arg4, double arg5, double arg6, double arg7) {
- if (hasCustomAccessor)
- for (IWorldAccess accessor : customAccessors)
- accessor.a(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
- }
-
- @Override
- @Deprecated
- public void a(ParticleParam arg0, boolean arg1, boolean arg2, double arg3, double arg4, double arg5, double arg6, double arg7, double arg8) {
- if (hasCustomAccessor)
- for (IWorldAccess accessor : customAccessors)
- accessor.a(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
- }
-}
\ No newline at end of file
diff --git a/src/main/java/io/akarin/server/core/PacketType.java b/src/main/java/io/akarin/server/core/PacketType.java
deleted file mode 100644
index 49dfacf08..000000000
--- a/src/main/java/io/akarin/server/core/PacketType.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package io.akarin.server.core;
-
-public enum PacketType {
- PLAY_OUT_MAP_CHUNK,
- PLAY_OUT_SPAWN_POSITION,
- PLAY_OUT_CHAT,
-
- UNKNOWN;
-}
\ No newline at end of file
diff --git a/src/main/java/io/akarin/server/misc/ChunkCoordOrdinalInt3Tuple.java b/src/main/java/io/akarin/server/misc/ChunkCoordOrdinalInt3Tuple.java
deleted file mode 100644
index de10f5bcf..000000000
--- a/src/main/java/io/akarin/server/misc/ChunkCoordOrdinalInt3Tuple.java
+++ /dev/null
@@ -1,47 +0,0 @@
-package io.akarin.server.misc;
-
-import net.minecraft.server.ChunkCoordIntPair;
-
-import com.google.common.hash.Hashing;
-import com.google.common.hash.HashFunction;
-
-/*
- * Reference on spawning mechanics by Colin Godsey
- * https://github.com/yesdog/Paper/blob/0de3dd84b7e6688feb42af4fe6b4f323ce7e3013/Spigot-Server-Patches/0433-alternate-mob-spawning-mechanic.patch
- */
-public class ChunkCoordOrdinalInt3Tuple extends ChunkCoordIntPair {
- public static final HashFunction hashFunc = Hashing.murmur3_32("akarin".hashCode());
-
- public final int ordinal;
- public final int cachedHashCode;
-
- public ChunkCoordOrdinalInt3Tuple(int x, int z, int ord) {
- super(x, z);
-
- this.ordinal = ord;
-
- cachedHashCode = hashFunc.newHasher()
- .putInt(ordinal)
- .putInt(x)
- .putInt(z)
- .hash().asInt();
- }
-
- @Override
- public int hashCode() {
- return cachedHashCode;
- }
-
- @Override
- public boolean equals(Object object) {
- if (this == object) {
- return true;
- } else if (!(object instanceof ChunkCoordOrdinalInt3Tuple)) {
- return false;
- } else {
- ChunkCoordOrdinalInt3Tuple pair = (ChunkCoordOrdinalInt3Tuple) object;
-
- return this.x == pair.x && this.z == pair.z && this.ordinal == pair.ordinal;
- }
- }
-}
\ No newline at end of file
diff --git a/src/main/java/io/akarin/server/misc/CopyOnWriteHashMap.java b/src/main/java/io/akarin/server/misc/CopyOnWriteHashMap.java
deleted file mode 100644
index ca9c60ea7..000000000
--- a/src/main/java/io/akarin/server/misc/CopyOnWriteHashMap.java
+++ /dev/null
@@ -1,184 +0,0 @@
-package io.akarin.server.misc;
-
-import java.io.Serializable;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.atomic.AtomicReference;
-
-/**
- * A thread-safe version of {@link Map} in which all operations that change the
- * Map are implemented by making a new copy of the underlying Map.
- *
- * While the creation of a new Map can be expensive, this class is designed for
- * cases in which the primary function is to read data from the Map, not to
- * modify the Map. Therefore the operations that do not cause a change to this
- * class happen quickly and concurrently.
- *
- * @author Kuzma Deretuke
- */
-public class CopyOnWriteHashMap implements Map, Serializable, Cloneable {
- private static final long serialVersionUID = 5481095911554321115L;
- private AtomicReference> internalMap = new AtomicReference>();
-
- /**
- * Creates a new instance of CopyOnWriteHashMap.
- */
- public CopyOnWriteHashMap() {
- internalMap.set(new HashMap());
- }
-
- /**
- * Creates a new instance of CopyOnWriteHashMap with the specified initial size.
- *
- * @param initialCapacity The initial size of the Map.
- */
- public CopyOnWriteHashMap(int initialCapacity) {
- internalMap.set(new HashMap(initialCapacity));
- }
-
- /**
- * Creates a new instance of CopyOnWriteHashMap in which the initial data,
- * being held by this map, is contained in the supplied map.
- *
- * @param data A Map containing the initial contents to be placed into this class.
- */
- public CopyOnWriteHashMap(Map data) {
- internalMap.set(new HashMap(data));
- }
-
- @Override
- public V put(K key, V value) {
- Map oldMap;
- Map newMap;
- V val;
- do {
- oldMap = internalMap.get();
- newMap = new HashMap(oldMap);
- val = newMap.put(key, value);
- }
- while (!internalMap.compareAndSet(oldMap, newMap));
- return val;
- }
-
- @Override
- public V remove(Object key) {
- Map oldMap;
- Map newMap;
- V val;
- do {
- oldMap = internalMap.get();
- newMap = new HashMap(oldMap);
- val = newMap.remove(key);
- }
- while (!internalMap.compareAndSet(oldMap, newMap));
- return val;
- }
-
- @Override
- public void putAll(Map newData) {
- Map oldMap;
- Map newMap;
- do {
- oldMap = internalMap.get();
- newMap = new HashMap(oldMap);
- newMap.putAll(newData);
- }
- while (!internalMap.compareAndSet(oldMap, newMap));
- }
-
- @Override
- public void clear() {
- internalMap.set(new HashMap());
- }
-
- //
- // Below are methods that do not modify the internal map
- //
-
- @Override
- public int size() {
- return internalMap.get().size();
- }
-
- @Override
- public boolean isEmpty() {
- return internalMap.get().isEmpty();
- }
-
- @Override
- public boolean containsKey(Object key) {
- return internalMap.get().containsKey(key);
- }
-
- @Override
- public boolean containsValue(Object value) {
- return internalMap.get().containsValue(value);
- }
-
- @Override
- public V get(Object key) {
- return internalMap.get().get(key);
- }
-
- @Override
- public Set keySet() {
- return internalMap.get().keySet();
- }
-
- @Override
- public Collection values() {
- return internalMap.get().values();
- }
-
- @Override
- public Set> entrySet() {
- return internalMap.get().entrySet();
- }
-
- @Override
- public int hashCode() {
- return internalMap.get().hashCode();
- }
-
- @Override
- public boolean equals(Object o) {
- return internalMap.get().equals(o);
- }
-
- @Override
- public String toString() {
- Map map = internalMap.get();
- Iterator> i = map.entrySet().iterator();
- if (!i.hasNext())
- return "{}";
-
- StringBuilder sb = new StringBuilder();
- sb.append('{');
- for (; ; ) {
- Entry e = i.next();
- K key = e.getKey();
- V value = e.getValue();
- sb.append(key == this ? "(this Map)" : (key == map ? "(internal Map)" : key));
- sb.append('=');
- sb.append(value == this ? "(this Map)" : (value == map ? "(internal Map)" : value));
- if (!i.hasNext())
- return sb.append('}').toString();
- sb.append(',').append(' ');
- }
- }
-
- @Override
- public Object clone() {
- try {
- CopyOnWriteHashMap clone = (CopyOnWriteHashMap) super.clone();
- clone.internalMap = new AtomicReference>(new HashMap(internalMap.get()));
- return clone;
- }
- catch (CloneNotSupportedException e) {
- throw new InternalError();
- }
- }
-}
\ No newline at end of file
diff --git a/src/main/java/net/minecraft/server/Advancement.java b/src/main/java/net/minecraft/server/Advancement.java
index b88d0207e..3ef2f4d2a 100644
--- a/src/main/java/net/minecraft/server/Advancement.java
+++ b/src/main/java/net/minecraft/server/Advancement.java
@@ -158,6 +158,10 @@ public class Advancement {
return this;
}
+ public Advancement.SerializedAdvancement a(ItemStack itemstack, IChatBaseComponent ichatbasecomponent, IChatBaseComponent ichatbasecomponent1, @Nullable MinecraftKey minecraftkey, AdvancementFrameType advancementframetype, boolean flag, boolean flag1, boolean flag2) {
+ return this.a(new AdvancementDisplay(itemstack, ichatbasecomponent, ichatbasecomponent1, minecraftkey, advancementframetype, flag, flag1, flag2));
+ }
+
public Advancement.SerializedAdvancement a(IMaterial imaterial, IChatBaseComponent ichatbasecomponent, IChatBaseComponent ichatbasecomponent1, @Nullable MinecraftKey minecraftkey, AdvancementFrameType advancementframetype, boolean flag, boolean flag1, boolean flag2) {
return this.a(new AdvancementDisplay(new ItemStack(imaterial.getItem()), ichatbasecomponent, ichatbasecomponent1, minecraftkey, advancementframetype, flag, flag1, flag2));
}
@@ -349,7 +353,7 @@ public class Advancement {
String s;
- for (Iterator iterator = map.keySet().iterator(); iterator.hasNext(); astring[i++] = new String[] { s}) {
+ for (Iterator iterator = map.keySet().iterator(); iterator.hasNext(); astring[i++] = new String[]{s}) {
s = (String) iterator.next();
}
}
@@ -413,13 +417,13 @@ public class Advancement {
}
public static Advancement.SerializedAdvancement b(PacketDataSerializer packetdataserializer) {
- MinecraftKey minecraftkey = packetdataserializer.readBoolean() ? packetdataserializer.l() : null;
+ MinecraftKey minecraftkey = packetdataserializer.readBoolean() ? packetdataserializer.o() : null;
AdvancementDisplay advancementdisplay = packetdataserializer.readBoolean() ? AdvancementDisplay.b(packetdataserializer) : null;
Map map = Criterion.c(packetdataserializer);
- String[][] astring = new String[packetdataserializer.g()][];
+ String[][] astring = new String[packetdataserializer.i()][];
for (int i = 0; i < astring.length; ++i) {
- astring[i] = new String[packetdataserializer.g()];
+ astring[i] = new String[packetdataserializer.i()];
for (int j = 0; j < astring[i].length; ++j) {
astring[i][j] = packetdataserializer.e(32767);
diff --git a/src/main/java/net/minecraft/server/AdvancementDataPlayer.java b/src/main/java/net/minecraft/server/AdvancementDataPlayer.java
index 8b07d6921..b7f1f39a1 100644
--- a/src/main/java/net/minecraft/server/AdvancementDataPlayer.java
+++ b/src/main/java/net/minecraft/server/AdvancementDataPlayer.java
@@ -1,6 +1,6 @@
package net.minecraft.server;
-import com.google.common.collect.Collections2;
+import com.google.common.base.Charsets;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
@@ -12,18 +12,14 @@ import com.google.gson.JsonParseException;
import com.google.gson.internal.Streams;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonReader;
-import com.koloboke.collect.map.hash.HashObjObjMaps;
-import com.mojang.datafixers.DataFixTypes;
import com.mojang.datafixers.Dynamic;
import com.mojang.datafixers.types.JsonOps;
-
-import io.akarin.server.core.AkarinAsyncExecutor;
-
import java.io.File;
+import java.io.FileOutputStream;
import java.io.IOException;
+import java.io.OutputStreamWriter;
import java.io.StringReader;
import java.nio.charset.StandardCharsets;
-import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
@@ -38,7 +34,7 @@ import org.apache.logging.log4j.Logger;
public class AdvancementDataPlayer {
- private static final Logger a = LogManager.getLogger();
+ private static final Logger LOGGER = LogManager.getLogger();
private static final Gson b = (new GsonBuilder()).registerTypeAdapter(AdvancementProgress.class, new AdvancementProgress.a()).registerTypeAdapter(MinecraftKey.class, new MinecraftKey.a()).setPrettyPrinting().create();
private static final TypeToken> c = new TypeToken>() {
};
@@ -87,7 +83,7 @@ public class AdvancementDataPlayer {
}
private void d() {
- Iterator iterator = this.d.getAdvancementData().b().iterator();
+ Iterator iterator = this.d.getAdvancementData().a().iterator();
while (iterator.hasNext()) {
Advancement advancement = (Advancement) iterator.next();
@@ -121,7 +117,7 @@ public class AdvancementDataPlayer {
}
private void f() {
- Iterator iterator = this.d.getAdvancementData().b().iterator();
+ Iterator iterator = this.d.getAdvancementData().a().iterator();
while (iterator.hasNext()) {
Advancement advancement = (Advancement) iterator.next();
@@ -144,11 +140,11 @@ public class AdvancementDataPlayer {
jsonreader.setLenient(false);
Dynamic dynamic = new Dynamic(JsonOps.INSTANCE, Streams.parse(jsonreader));
- if (!dynamic.get("DataVersion").flatMap(Dynamic::getNumberValue).isPresent()) {
+ if (!dynamic.get("DataVersion").asNumber().isPresent()) {
dynamic = dynamic.set("DataVersion", dynamic.createInt(1343));
}
- dynamic = this.d.az().update(DataFixTypes.ADVANCEMENTS, dynamic, dynamic.getInt("DataVersion"), 1631);
+ dynamic = this.d.aB().update(DataFixTypes.ADVANCEMENTS.a(), dynamic, dynamic.get("DataVersion").asInt(0), SharedConstants.a().getWorldVersion());
dynamic = dynamic.remove("DataVersion");
Map map = (Map) AdvancementDataPlayer.b.getAdapter(AdvancementDataPlayer.c).fromJsonTree((JsonElement) dynamic.getValue());
@@ -165,8 +161,8 @@ public class AdvancementDataPlayer {
if (advancement == null) {
// CraftBukkit start
- if (((MinecraftKey) entry.getKey()).b().equals("minecraft")) {
- AdvancementDataPlayer.a.warn("Ignored advancement '{}' in progress file {} - it doesn't exist anymore?", entry.getKey(), this.e);
+ if (entry.getKey().getNamespace().equals("minecraft")) {
+ AdvancementDataPlayer.LOGGER.warn("Ignored advancement '{}' in progress file {} - it doesn't exist anymore?", entry.getKey(), this.e);
}
// CraftBukkit end
} else {
@@ -191,9 +187,9 @@ public class AdvancementDataPlayer {
}
} catch (JsonParseException jsonparseexception) {
- AdvancementDataPlayer.a.error("Couldn't parse player advancements in {}", this.e, jsonparseexception);
+ AdvancementDataPlayer.LOGGER.error("Couldn't parse player advancements in {}", this.e, jsonparseexception);
} catch (IOException ioexception) {
- AdvancementDataPlayer.a.error("Couldn't access player advancements in {}", this.e, ioexception);
+ AdvancementDataPlayer.LOGGER.error("Couldn't access player advancements in {}", this.e, ioexception);
}
}
@@ -202,33 +198,6 @@ public class AdvancementDataPlayer {
this.d();
}
- // Akarin start - copied from below
- public Map toSerializableMap() {
- Map map = HashObjObjMaps.newMutableMap();
- Iterator> iterator = this.data.entrySet().iterator();
-
- while (iterator.hasNext()) {
- Entry entry = iterator.next();
- AdvancementProgress advancementprogress = (AdvancementProgress) entry.getValue();
-
- if (advancementprogress.b()) {
- map.put(((Advancement) entry.getKey()).getName(), advancementprogress);
- }
- }
- return map;
- }
- public void save(Map serializableMap) {
- if (this.e.getParentFile() != null) {
- this.e.getParentFile().mkdirs();
- }
-
- try {
- Files.write(AdvancementDataPlayer.b.toJson(serializableMap), this.e, StandardCharsets.UTF_8);
- } catch (IOException ioexception) {
- AdvancementDataPlayer.a.error("Couldn't save player advancements to {}", this.e, ioexception);
- }
- }
- // Akarin end
public void c() {
if (org.spigotmc.SpigotConfig.disableAdvancementSaving) return;
Map map = Maps.newHashMap();
@@ -247,10 +216,56 @@ public class AdvancementDataPlayer {
this.e.getParentFile().mkdirs();
}
+ JsonElement jsonelement = AdvancementDataPlayer.b.toJsonTree(map);
+
+ jsonelement.getAsJsonObject().addProperty("DataVersion", SharedConstants.a().getWorldVersion());
+
try {
- Files.write(AdvancementDataPlayer.b.toJson(map), this.e, StandardCharsets.UTF_8);
+ FileOutputStream fileoutputstream = new FileOutputStream(this.e);
+ Throwable throwable = null;
+
+ try {
+ OutputStreamWriter outputstreamwriter = new OutputStreamWriter(fileoutputstream, Charsets.UTF_8.newEncoder());
+ Throwable throwable1 = null;
+
+ try {
+ AdvancementDataPlayer.b.toJson(jsonelement, outputstreamwriter);
+ } catch (Throwable throwable2) {
+ throwable1 = throwable2;
+ throw throwable2;
+ } finally {
+ if (outputstreamwriter != null) {
+ if (throwable1 != null) {
+ try {
+ outputstreamwriter.close();
+ } catch (Throwable throwable3) {
+ throwable1.addSuppressed(throwable3);
+ }
+ } else {
+ outputstreamwriter.close();
+ }
+ }
+
+ }
+ } catch (Throwable throwable4) {
+ throwable = throwable4;
+ throw throwable4;
+ } finally {
+ if (fileoutputstream != null) {
+ if (throwable != null) {
+ try {
+ fileoutputstream.close();
+ } catch (Throwable throwable5) {
+ throwable.addSuppressed(throwable5);
+ }
+ } else {
+ fileoutputstream.close();
+ }
+ }
+
+ }
} catch (IOException ioexception) {
- AdvancementDataPlayer.a.error("Couldn't save player advancements to {}", this.e, ioexception);
+ AdvancementDataPlayer.LOGGER.error("Couldn't save player advancements to {}", this.e, ioexception);
}
}
@@ -273,8 +288,8 @@ public class AdvancementDataPlayer {
if (!flag1 && advancementprogress.isDone()) {
this.player.world.getServer().getPluginManager().callEvent(new org.bukkit.event.player.PlayerAdvancementDoneEvent(this.player.getBukkitEntity(), advancement.bukkit)); // CraftBukkit
advancement.d().a(this.player);
- if (advancement.c() != null && advancement.c().i() && this.player.world.getGameRules().getBoolean("announceAdvancements")) {
- this.d.getPlayerList().sendMessage(new ChatMessage("chat.type.advancement." + advancement.c().e().a(), new Object[] { this.player.getScoreboardDisplayName(), advancement.j()}));
+ if (advancement.c() != null && advancement.c().i() && this.player.world.getGameRules().getBoolean(GameRules.ANNOUNCE_ADVANCEMENTS)) {
+ this.d.getPlayerList().sendMessage(new ChatMessage("chat.type.advancement." + advancement.c().e().a(), new Object[]{this.player.getScoreboardDisplayName(), advancement.j()}));
}
}
}
diff --git a/src/main/java/net/minecraft/server/AdvancementDataWorld.java b/src/main/java/net/minecraft/server/AdvancementDataWorld.java
index 9f9e5484d..54f6331ec 100644
--- a/src/main/java/net/minecraft/server/AdvancementDataWorld.java
+++ b/src/main/java/net/minecraft/server/AdvancementDataWorld.java
@@ -7,105 +7,51 @@ import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
-import java.io.IOException;
import java.lang.reflect.Type;
-import java.nio.charset.StandardCharsets;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import javax.annotation.Nullable;
-import org.apache.commons.io.IOUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
-public class AdvancementDataWorld implements IResourcePackListener {
+public class AdvancementDataWorld extends ResourceDataJson {
- private static final Logger c = LogManager.getLogger();
+ private static final Logger LOGGER = LogManager.getLogger();
public static final Gson DESERIALIZER = (new GsonBuilder()).registerTypeHierarchyAdapter(Advancement.SerializedAdvancement.class, (com.google.gson.JsonDeserializer) (jsonelement, type, jsondeserializationcontext) -> {
JsonObject jsonobject = ChatDeserializer.m(jsonelement, "advancement");
return Advancement.SerializedAdvancement.a(jsonobject, jsondeserializationcontext);
}).registerTypeAdapter(AdvancementRewards.class, new AdvancementRewards.b()).registerTypeHierarchyAdapter(IChatBaseComponent.class, new IChatBaseComponent.ChatSerializer()).registerTypeHierarchyAdapter(ChatModifier.class, new ChatModifier.ChatModifierSerializer()).registerTypeAdapterFactory(new ChatTypeAdapterFactory()).create();
- public static final Advancements REGISTRY = new Advancements();
- public static final int a = "advancements/".length();
- public static final int b = ".json".length();
- private boolean f;
+ public Advancements REGISTRY = new Advancements();
- public AdvancementDataWorld() {}
+ public AdvancementDataWorld() {
+ super(AdvancementDataWorld.DESERIALIZER, "advancements");
+ }
- private Map b(IResourceManager iresourcemanager) {
- Map map = Maps.newHashMap();
- Iterator iterator = iresourcemanager.a("advancements", (s) -> {
- return s.endsWith(".json");
- }).iterator();
+ protected void a(Map map, IResourceManager iresourcemanager, GameProfilerFiller gameprofilerfiller) {
+ Map map1 = Maps.newHashMap();
- while (iterator.hasNext()) {
- MinecraftKey minecraftkey = (MinecraftKey) iterator.next();
- String s = minecraftkey.getKey();
- MinecraftKey minecraftkey1 = new MinecraftKey(minecraftkey.b(), s.substring(AdvancementDataWorld.a, s.length() - AdvancementDataWorld.b));
+ map.forEach((minecraftkey, jsonobject) -> {
+ // Spigot start
+ if (org.spigotmc.SpigotConfig.disabledAdvancements != null && (org.spigotmc.SpigotConfig.disabledAdvancements.contains("*") || org.spigotmc.SpigotConfig.disabledAdvancements.contains(minecraftkey.toString()))) {
+ return;
+ }
+ // Spigot end
try {
- IResource iresource = iresourcemanager.a(minecraftkey);
- Throwable throwable = null;
- // Spigot start
- if (org.spigotmc.SpigotConfig.disabledAdvancements != null && (org.spigotmc.SpigotConfig.disabledAdvancements.contains("*") || org.spigotmc.SpigotConfig.disabledAdvancements.contains(minecraftkey.toString()))) {
- continue;
- }
- // Spigot end
+ Advancement.SerializedAdvancement advancement_serializedadvancement = (Advancement.SerializedAdvancement) AdvancementDataWorld.DESERIALIZER.fromJson(jsonobject, Advancement.SerializedAdvancement.class);
- try {
- Advancement.SerializedAdvancement advancement_serializedadvancement = (Advancement.SerializedAdvancement) ChatDeserializer.a(AdvancementDataWorld.DESERIALIZER, IOUtils.toString(iresource.b(), StandardCharsets.UTF_8), Advancement.SerializedAdvancement.class);
-
- if (advancement_serializedadvancement == null) {
- AdvancementDataWorld.c.error("Couldn't load custom advancement {} from {} as it's empty or null", minecraftkey1, minecraftkey);
- } else {
- map.put(minecraftkey1, advancement_serializedadvancement);
- }
- } catch (Throwable throwable1) {
- throwable = throwable1;
- throw throwable1;
- } finally {
- if (iresource != null) {
- if (throwable != null) {
- try {
- iresource.close();
- } catch (Throwable throwable2) {
- throwable.addSuppressed(throwable2);
- }
- } else {
- iresource.close();
- }
- }
-
- }
+ map1.put(minecraftkey, advancement_serializedadvancement);
} catch (IllegalArgumentException | JsonParseException jsonparseexception) {
- AdvancementDataWorld.c.error("Parsing error loading custom advancement {}: {}", minecraftkey1, jsonparseexception.getMessage());
- this.f = true;
- } catch (IOException ioexception) {
- AdvancementDataWorld.c.error("Couldn't read custom advancement {} from {}", minecraftkey1, minecraftkey, ioexception);
- this.f = true;
+ AdvancementDataWorld.LOGGER.error("Parsing error loading custom advancement {}: {}", minecraftkey, jsonparseexception.getMessage());
}
- }
- return map;
- }
+ });
+ Advancements advancements = new Advancements();
- @Nullable
- public Advancement a(MinecraftKey minecraftkey) {
- return AdvancementDataWorld.REGISTRY.a(minecraftkey);
- }
-
- public Collection b() {
- return AdvancementDataWorld.REGISTRY.c();
- }
-
- public void a(IResourceManager iresourcemanager) {
- this.f = false;
- AdvancementDataWorld.REGISTRY.a();
- Map map = this.b(iresourcemanager);
-
- AdvancementDataWorld.REGISTRY.a(map);
- Iterator iterator = AdvancementDataWorld.REGISTRY.b().iterator();
+ advancements.a((Map) map1);
+ Iterator iterator = advancements.b().iterator();
while (iterator.hasNext()) {
Advancement advancement = (Advancement) iterator.next();
@@ -115,5 +61,15 @@ public class AdvancementDataWorld implements IResourcePackListener {
}
}
+ this.REGISTRY = advancements;
+ }
+
+ @Nullable
+ public Advancement a(MinecraftKey minecraftkey) {
+ return this.REGISTRY.a(minecraftkey);
+ }
+
+ public Collection a() {
+ return this.REGISTRY.c();
}
}
diff --git a/src/main/java/net/minecraft/server/Advancements.java b/src/main/java/net/minecraft/server/Advancements.java
index 5d32caff3..bc043ad4f 100644
--- a/src/main/java/net/minecraft/server/Advancements.java
+++ b/src/main/java/net/minecraft/server/Advancements.java
@@ -15,7 +15,7 @@ import org.apache.logging.log4j.Logger;
public class Advancements {
- private static final Logger a = LogManager.getLogger();
+ private static final Logger LOGGER = LogManager.getLogger();
public final Map advancements = Maps.newHashMap();
private final Set c = Sets.newLinkedHashSet();
private final Set d = Sets.newLinkedHashSet();
@@ -67,22 +67,12 @@ public class Advancements {
}
entry = (Entry) iterator.next();
- Advancements.a.error("Couldn't load advancement {}: {}", entry.getKey(), entry.getValue());
+ Advancements.LOGGER.error("Couldn't load advancement {}: {}", entry.getKey(), entry.getValue());
}
}
}
- // Advancements.a.info("Loaded {} advancements", this.advancements.size()); // CraftBukkit - moved to AdvancementDataWorld#reload
- }
-
- public void a() {
- this.advancements.clear();
- this.c.clear();
- this.d.clear();
- if (this.e != null) {
- this.e.a();
- }
-
+ // Advancements.LOGGER.info("Loaded {} advancements", this.advancements.size()); // CraftBukkit - moved to AdvancementDataWorld#reload
}
public Iterable b() {
@@ -103,7 +93,5 @@ public class Advancements {
void a(Advancement advancement);
void c(Advancement advancement);
-
- void a();
}
}
diff --git a/src/main/java/net/minecraft/server/AkarinUserCache.java b/src/main/java/net/minecraft/server/AkarinUserCache.java
deleted file mode 100644
index 53008f775..000000000
--- a/src/main/java/net/minecraft/server/AkarinUserCache.java
+++ /dev/null
@@ -1,262 +0,0 @@
-package net.minecraft.server;
-
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.text.SimpleDateFormat;
-import java.util.Calendar;
-import java.util.Collections;
-import java.util.Date;
-import java.util.List;
-import java.util.Locale;
-import java.util.concurrent.TimeUnit;
-import java.util.function.Consumer;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
-import org.apache.commons.io.IOUtils;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.spigotmc.SpigotConfig;
-
-import com.destroystokyo.paper.PaperConfig;
-import com.github.benmanes.caffeine.cache.Cache;
-import com.github.benmanes.caffeine.cache.Caffeine;
-import com.google.common.base.Charsets;
-import com.google.common.collect.Lists;
-import com.google.common.io.Files;
-import com.google.gson.Gson;
-import com.google.gson.JsonParseException;
-import com.google.gson.JsonSyntaxException;
-import com.mojang.authlib.Agent;
-import com.mojang.authlib.GameProfile;
-import com.mojang.authlib.GameProfileRepository;
-import com.mojang.authlib.ProfileLookupCallback;
-import io.akarin.server.core.AkarinAsyncExecutor;
-import io.akarin.server.core.AkarinGlobalConfig;
-import net.minecraft.server.UserCache.UserCacheEntry;
-
-public class AkarinUserCache {
- private final static Logger LOGGER = LogManager.getLogger("Akarin");
- public static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z");
-
- // To reduce date creation
- private final static long RECREATE_DATE_INTERVAL = TimeUnit.MILLISECONDS.convert(10, TimeUnit.MINUTES);
- private static long lastWarpExpireDate;
- private static Date lastExpireDate;
-
- /**
- * All user caches
- * String username -> UserCacheEntry cacheEntry (profile and expire date)
- */
- private final Cache profiles = Caffeine.newBuilder().maximumSize(SpigotConfig.userCacheCap).build();
-
- private final GameProfileRepository profileHandler;
- protected final Gson gson;
- private final File userCacheFile;
-
- protected static boolean isOnlineMode() {
- return UserCache.isOnlineMode() || (SpigotConfig.bungee && PaperConfig.bungeeOnlineMode);
- }
-
- private static Date createExpireDate(boolean force) {
- long now = System.currentTimeMillis();
- if (force || (now - lastWarpExpireDate) > RECREATE_DATE_INTERVAL) {
- lastWarpExpireDate = now;
- Calendar calendar = Calendar.getInstance();
-
- calendar.add(Calendar.SECOND, AkarinGlobalConfig.userCacheExpireDays);
- return lastExpireDate = calendar.getTime();
- }
-
- return lastExpireDate;
- }
-
- private static boolean isExpired(UserCacheEntry entry) {
- return System.currentTimeMillis() >= entry.getExpireDate().getTime();
- }
-
- private static UserCacheEntry refreshExpireDate(UserCacheEntry entry) {
- return new UserCacheEntry(entry.getProfile(), createExpireDate(true));
- }
-
- private static GameProfile lookup(GameProfileRepository profileRepo, String username, @Nonnull Consumer cachedCallbackHandler, boolean async) {
- GameProfile[] gameProfile = new GameProfile[1];
- ProfileLookupCallback handler = new ProfileLookupCallback() {
- @Override
- public void onProfileLookupSucceeded(GameProfile gameprofile) {
- cachedCallbackHandler.accept(gameprofile);
- gameProfile[0] = gameprofile;
- }
-
- @Override
- public void onProfileLookupFailed(GameProfile gameprofile, Exception ex) {
- LOGGER.warn("Failed to lookup profile for player {}, applying offline UUID.", gameprofile.getName());
- GameProfile offline = createOfflineProfile(username);
- cachedCallbackHandler.accept(offline);
- gameProfile[0] = offline;
- }
- };
-
- Runnable find = () -> profileRepo.findProfilesByNames(new String[]{username}, Agent.MINECRAFT, handler);
- if (async) {
- AkarinAsyncExecutor.scheduleAsyncTask(find);
- } else {
- find.run();
- }
- return gameProfile[0];
- }
-
- private static GameProfile createOfflineProfile(String username) {
- String usernameOffline = username.toLowerCase(Locale.ROOT);
- GameProfile offlineProfile = new GameProfile(EntityHuman.getOfflineUUID(usernameOffline), username);
- return offlineProfile;
- }
-
- public AkarinUserCache(GameProfileRepository repo, File file, Gson gson) {
- lastExpireDate = createExpireDate(true);
-
- this.profileHandler = repo;
- this.userCacheFile = file;
- this.gson = gson;
-
- this.load();
- }
-
- private GameProfile lookupAndCache(String username, @Nullable Consumer callback, boolean async) {
- return lookupAndCache(username, callback, createExpireDate(false), async);
- }
-
- private GameProfile lookupAndCache(String username, @Nullable Consumer callback, Date expireDate, boolean async) {
- Consumer cachedCallbackHandler = profile -> {
- profiles.put(username, new UserCacheEntry(profile, expireDate));
- if (async)
- callback.accept(profile);
-
- if (!org.spigotmc.SpigotConfig.saveUserCacheOnStopOnly)
- save();
- };
-
- GameProfileRepository repository = MinecraftServer.getServer().getUserCache().gameProfileRepository();
- return lookup(repository != null ? repository : profileHandler, username, cachedCallbackHandler, async);
- }
-
- public GameProfile acquire(String username) {
- return acquire(username, null, false);
- }
-
- public GameProfile acquire(String username, @Nonnull Consumer callback) {
- return acquire(username, callback, true);
- }
-
- public GameProfile acquire(String username, @Nullable Consumer callback, boolean async) {
- if (StringUtils.isBlank(username))
- throw new UnsupportedOperationException("Blank username");
-
- if (!isOnlineMode())
- return createOfflineProfile(username);
-
- UserCacheEntry entry = profiles.getIfPresent(username);
-
- if (entry != null) {
- if (isExpired(entry)) {
- profiles.invalidate(username);
- } else {
- if (async)
- callback.accept(entry.getProfile());
-
- return entry.getProfile();
- }
- }
- return lookupAndCache(username, callback, async);
- }
-
- @Nullable
- public GameProfile peek(String username) {
- if (!isOnlineMode())
- return createOfflineProfile(username);
-
- UserCacheEntry entry = profiles.getIfPresent(username);
- return entry == null ? null : entry.getProfile();
- }
-
- protected void offer(GameProfile profile) {
- if (isOnlineMode())
- offer(profile, createExpireDate(false));
- }
-
- private void offer(GameProfile profile, Date date) {
- String username = profile.getName();
- UserCacheEntry entry = profiles.getIfPresent(username);
- // Refresh expire date or create new entry
- entry = entry != null ? refreshExpireDate(entry) : new UserCacheEntry(profile, date);
-
- profiles.put(username, entry);
- }
-
- private void offer(UserCacheEntry entry) {
- if (!isExpired(entry))
- profiles.put(entry.getProfile().getName(), entry);
- }
-
- protected void load() {
- if (!isOnlineMode())
- return;
-
- BufferedReader reader = null;
- try {
- profiles.invalidateAll();
-
- reader = Files.newReader(userCacheFile, Charsets.UTF_8);
- List entries;
- synchronized (this.userCacheFile) {
- entries = this.gson.fromJson(reader, UserCache.PARAMETERIZED_TYPE);
- }
-
- if (entries != null && !entries.isEmpty())
- Lists.reverse(entries).forEach(this::offer);
- } catch (FileNotFoundException e) {
- ;
- } catch (JsonSyntaxException e) {
- LOGGER.warn("Usercache.json is corrupted or has bad formatting. Deleting it to prevent further issues.");
- this.userCacheFile.delete();
- } catch (JsonParseException e) {
- ;
- } finally {
- IOUtils.closeQuietly(reader);
- }
- }
-
- protected void save() {
- if (!isOnlineMode())
- return;
-
- Runnable save = () -> {
- String jsonString = this.gson.toJson(this.entries());
- BufferedWriter writer = null;
-
- try {
- writer = Files.newWriter(this.userCacheFile, Charsets.UTF_8);
- synchronized (this.userCacheFile) {
- writer.write(jsonString);
- }
- } catch (FileNotFoundException e) {
- ;
- } catch (IOException io) {
- ;
- } finally {
- IOUtils.closeQuietly(writer);
- }
- };
-
- AkarinAsyncExecutor.scheduleSingleAsyncTask(save);
- }
-
- private List entries() {
- return isOnlineMode() ? Lists.newArrayList(profiles.asMap().values()) : Collections.emptyList();
- }
-}
\ No newline at end of file
diff --git a/src/main/java/net/minecraft/server/ArgumentBlock.java b/src/main/java/net/minecraft/server/ArgumentBlock.java
index f52936581..97d85f845 100644
--- a/src/main/java/net/minecraft/server/ArgumentBlock.java
+++ b/src/main/java/net/minecraft/server/ArgumentBlock.java
@@ -23,19 +23,19 @@ public class ArgumentBlock {
public static final SimpleCommandExceptionType a = new SimpleCommandExceptionType(new ChatMessage("argument.block.tag.disallowed", new Object[0]));
public static final DynamicCommandExceptionType b = new DynamicCommandExceptionType((object) -> {
- return new ChatMessage("argument.block.id.invalid", new Object[] { object});
+ return new ChatMessage("argument.block.id.invalid", new Object[]{object});
});
public static final Dynamic2CommandExceptionType c = new Dynamic2CommandExceptionType((object, object1) -> {
- return new ChatMessage("argument.block.property.unknown", new Object[] { object, object1});
+ return new ChatMessage("argument.block.property.unknown", new Object[]{object, object1});
});
public static final Dynamic2CommandExceptionType d = new Dynamic2CommandExceptionType((object, object1) -> {
- return new ChatMessage("argument.block.property.duplicate", new Object[] { object1, object});
+ return new ChatMessage("argument.block.property.duplicate", new Object[]{object1, object});
});
public static final Dynamic3CommandExceptionType e = new Dynamic3CommandExceptionType((object, object1, object2) -> {
- return new ChatMessage("argument.block.property.invalid", new Object[] { object, object2, object1});
+ return new ChatMessage("argument.block.property.invalid", new Object[]{object, object2, object1});
});
public static final Dynamic2CommandExceptionType f = new Dynamic2CommandExceptionType((object, object1) -> {
- return new ChatMessage("argument.block.property.novalue", new Object[] { object, object1});
+ return new ChatMessage("argument.block.property.novalue", new Object[]{object, object1});
});
public static final SimpleCommandExceptionType g = new SimpleCommandExceptionType(new ChatMessage("argument.block.property.unclosed", new Object[0]));
private static final Function> h = SuggestionsBuilder::buildFuture;
@@ -216,7 +216,7 @@ public class ArgumentBlock {
}
private static > SuggestionsBuilder a(SuggestionsBuilder suggestionsbuilder, IBlockState iblockstate) {
- Iterator iterator = iblockstate.d().iterator();
+ Iterator iterator = iblockstate.getValues().iterator();
while (iterator.hasNext()) {
T t0 = (T) iterator.next(); // CraftBukkit - decompile error
@@ -335,15 +335,13 @@ public class ArgumentBlock {
int i = this.i.getCursor();
this.m = MinecraftKey.a(this.i);
- if (IRegistry.BLOCK.c(this.m)) {
- Block block = (Block) IRegistry.BLOCK.getOrDefault(this.m);
-
- this.n = block.getStates();
- this.o = block.getBlockData();
- } else {
+ Block block = (Block) IRegistry.BLOCK.getOptional(this.m).orElseThrow(() -> {
this.i.setCursor(i);
- throw ArgumentBlock.b.createWithContext(this.i, this.m.toString());
- }
+ return ArgumentBlock.b.createWithContext(this.i, this.m.toString());
+ });
+
+ this.n = block.getStates();
+ this.o = block.getBlockData();
}
public void f() throws CommandSyntaxException {
@@ -498,7 +496,7 @@ public class ArgumentBlock {
}
}
- public static String a(IBlockData iblockdata, @Nullable NBTTagCompound nbttagcompound) {
+ public static String a(IBlockData iblockdata) {
StringBuilder stringbuilder = new StringBuilder(IRegistry.BLOCK.getKey(iblockdata.getBlock()).toString());
if (!iblockdata.a().isEmpty()) {
@@ -518,10 +516,6 @@ public class ArgumentBlock {
stringbuilder.append(']');
}
- if (nbttagcompound != null) {
- stringbuilder.append(nbttagcompound);
- }
-
return stringbuilder.toString();
}
diff --git a/src/main/java/net/minecraft/server/ArgumentEntity.java b/src/main/java/net/minecraft/server/ArgumentEntity.java
index 5164b79b0..39a6a9ac0 100644
--- a/src/main/java/net/minecraft/server/ArgumentEntity.java
+++ b/src/main/java/net/minecraft/server/ArgumentEntity.java
@@ -39,7 +39,7 @@ public class ArgumentEntity implements ArgumentType {
return ((EntitySelector) commandcontext.getArgument(s, EntitySelector.class)).a((CommandListenerWrapper) commandcontext.getSource());
}
- public static ArgumentEntity b() {
+ public static ArgumentEntity multipleEntities() {
return new ArgumentEntity(false, false);
}
@@ -54,7 +54,7 @@ public class ArgumentEntity implements ArgumentType