Update gradle version to 6.1

bStats 1.7 requires plugins to have an ID to submit data.

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,28 @@
+__*NOTICE: Bukkit/Spigot versions 1.7.10 to 1.12.2 are considered legacy and will receive limited support. Please consider upgrading to 1.13 for future support. Plugins exist for 1.13+ that bring back old behaviors found in 1.8*__
+# Bug report template 
+<!--- In order to create a valid issue report you have to follow this template. -->
+<!--- Incomplete reports might be marked as invalid. -->
+<!--  Feature requests and enhancements may be suggested at https://github.com/IntellectualSites/PlotSquaredSuggestions. -->
+**Debug paste link:** 
+<!--- Enter /plot debugpaste in game or in your console and copy the output here -->
+
+**[REQUIRED] Spigot/Paper Version Number:** 
+
+**[REQUIRED] Minecraft Version Number:** 
+
+**[REQUIRED] Description of the problem:** 
+
+**Any relevant console output or screenshots:**
+
+**Plugins being used on the server:**
+<!--- Optional but recommended --->
+
+**How to replicate:** 
+<!--- If you can reproduce the issue please tell us as detailed as possible step by step how to do that -->
+
+**Checklist**:
+<!-- Make sure you have completed the following steps (put an "X" between of brackets): -->
+- [] I included all information required in the sections above
+- [] I made sure there are no duplicates of this report [(Use Search)](https://github.com/IntellectualSites/PlotSquared/issues?utf8=%E2%9C%93&q=is%3Aissue)
+- [] I made sure I am using an up-to-date version of PlotSquared
+- [] I made sure the bug/error is not caused by any other plugin

.github/ISSUE_TEMPLATE/bug-issue-report-for-plotsquared.md

@@ -0,0 +1,98 @@
+---
+name: Bug/Issue report for PlotSquared
+about: Bug / Issue report about this plugin
+title: ''
+labels: "[?] Testing Required"
+assignees: ''
+
+---
+
+<!--- READ THIS BEFORE SUBMITTING AN ISSUE REPORT!!! -->
+
+<!--- ##### DO NOT REMOVE THIS TEMPLATE!  YOUR ISSUE *WILL* FIT IN IT! ##### -->
+
+<!--- # NOTICE: 
+```diff
+! PlotSquared for Minecraft Java Edition versions between 1.7 through to 1.12.2 are considered
+! legacy, and will receive limited to no support. Please consider upgrading to 1.13+ for
+! future support.  Plugins exist for 1.13+ which bring back behaviors found in 1.8.8
+! All versions of PlotSquared for Sponge and Nukkit(X) will receive limited to no support
+! due to lack of developer interest and time. Additionally, NukkitX has not had feature
+! updates since the Better Together, which prevents some PlotSquared features from ever
+! functioning. Contributions are always welcome however!
+```
+
+**Feature requests & Suggestions are to be submitted at the [PlotSquared Suggestions tracker](https://github.com/IntellectualSites/PlotSquaredSuggestions)**
+
+**Code contributions are to be done through [PRs](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/creating-a-pull-request), tagging the specific issue ticket(s) if applicable.**
+
+**[DISCORD INVITE LINK](https://discord.gg/cSMxtGn)** and please, for the love of the little sanity we have left, use the correct channels!
+-->
+
+# Bug Report Template:
+<!--- Incomplete reports will most likely be marked as invalid, and closed, with few exceptions.-->
+## Required Information section:
+> ALL FIELDS  IN THIS SECTION ARE REQUIRED, and must contain appropriate information
+### Server config info (/plot debugpaste / file paste links):
+<!--- Issue /plot debugpaste in game or in your console and copy the supplied URL here -->
+<!--- If you cannot perform the above, we require logs/latest.log; settings.yml; worlds.yml and possibly PlotSquared.use_THIS.yml -->
+<!--- If you are unwilling to supply the information we need, we reserve the right to not assist you. Redact IP addresses if you need to. -->
+
+### Server type:
+**Select one**
+<!-- Select the type you are reporting the issue for (put an "X" between of brackets): -->
+- [] Spigot / Paper *(CraftBukkit should not be used, re-test with Spigot first!)*
+- [] Sponge *- NOTE: NOT ACTIVELY MAINTAINED*
+- [] NukkitX *- NOTE: NOT ACTIVELY MAINTAINED*
+
+### Minecraft Version:
+**Select one**
+<!-- Select the type you are reporting the issue for (put an "X" between of brackets): 
+The maintained versions are 1.14.4 and 1.15.x -->
+- [] Minecraft 1.15
+- [] Minecraft 1.14.4
+- [] Minecraft 1.13.2
+- [] Minecraft Java Edition *other versions, please specify*:
+- [] Minecraft Bedrock Edition *specify version*:
+
+### Server build info: 
+<!--- Run /version in-game or in console & paste the full output here: -->
+```
+Paste the output here, between the tick marks, replacing this text
+```
+
+### WorldEdit/FAWE versions:
+<!--- Specify which plugin you are using, and add its version -->
+- [] FAWE *version*:
+- [] WorldEdit *version*: 
+
+### Description of the problem:
+<!--- Be as specific as possible.  Don't lie, redact information, or use false names/situations. -->
+<!--- Who, What, When, Where, Why, How, Expected behavior, Resultant behavior, etc -->
+
+### How to replicate:
+<!--- If you can reproduce the issue please tell us as detailed as possible step by step how to do that -->
+
+## Additional Information:
+> The information here is optional for you to provide, however it may help us to more readily diagnose any compatibility and bug issues.
+
+### Other plugins being used on the server:
+<!--- Optional but recommended - issue "/plugins" in-game or in console and copy/paste the list -->
+
+### Relevant console output, log lines, and/or screenshots:
+<!--- Please use in-line code insertion 
+```
+like this
+```
+for short (20 lines or less) text blobs, or a paste service for large blobs -->
+
+### Additional relevant comments/remarks:
+<!--- Use this space to give us any additional information which may be relevant to this issue, such as: if you are using a Minecraft hosting provider; unusual installation environment; etc -->
+
+# AFFIRMATION OF COMPLETION:
+<!-- Make sure you have completed the following steps (put an "X" between of brackets): -->
+- [] I included all information required in the sections above
+- [] I made sure there are no duplicates of this report [(Use Search)](https://github.com/IntellectualSites/PlotSquared/issues?utf8=%E2%9C%93&q=is%3Aissue)
+- [] I made sure I am using an up-to-date version of PlotSquared
+- [] I made sure the bug/error is not caused by any other plugin
+- [x] I didn't read but checked everything above.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: PlotSquared Suggestions
+    url: https://github.com/IntellectualSites/PlotSquaredSuggestions
+    about: If you want to submit feature or suggestion ideas, do that here

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,17 @@
+## Overview
+<!--  Please describe which issue this Pull Request targets
+
+If there is no issue, please create one so we can look into it before approving your PR.
+You can do so here: https://github.com/IntellectualSites/PlotSquared/issues/new/choose
+-->
+
+**Fixes #{issue number}**
+
+## Description
+
+## Checklist
+<!-- Make sure you have completed the following steps (put an "X" between of brackets): -->
+- [] I included all information required in the sections above
+- [] I tested my changes and approved their functionality
+- [] I ensured my changes do not break other parts of the code
+- [] I read and followed the [contribution guidelines](https://github.com/IntellectualSites/PlotSquared/blob/breaking/CONTRIBUTING.md)

.github/auto-comment.yml

@@ -0,0 +1,8 @@
+# Comment to a new issue.
+issueOpened: >
+  Thank your for raising a issue. We will try and get back to you as soon as possible.
+
+  Please make sure that you followed the issue template, and provided all neccessary information.
+  Failure to do so will prevent us from resolving the issue in a timely manner. 
+  
+  Please note that suggestions are now to be submitted to https://git.io/fN5B4 rather than this issue tracker!

.github/stale.yml

@@ -0,0 +1,16 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 60
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - [‼] high priority
+# Label to use when marking an issue as stale
+staleLabel: Old
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false

.github/workflows/gradle.yml

@@ -0,0 +1,26 @@
+name: Java CI
+
+on:
+  push:
+    branches:
+    - v4
+    - v5
+    - leagcy/1.8-1.12
+  pull_request:
+    branches:
+    - v4
+    - v5
+    - leagcy/1.8-1.12
+ 
+jobs:
+  test:
+    runs-on: ubuntu-18.04
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: Set up JDK 1.8
+      uses: actions/setup-java@v1
+      with:
+        java-version: 1.8
+    - name: Test with Gradle
+      run: ./gradlew clean build

.gitignore

@@ -1,9 +1,18 @@
-### Ignore script files
+### Others ###
+*.cmd
 *.sh
-*.bat
+*.prefs
+Sponge/build
+Core/build
+Bukkit/build
+Nukkit/build
 
-### Maven template
-target/
+### Maven ###
+/mvn
+/target/lib
+/target/maven-archiver
+/target/classes
+/target/maven-status
 pom.xml.tag
 pom.xml.releaseBackup
 pom.xml.versionsBackup
@@ -12,10 +21,25 @@ release.properties
 dependency-reduced-pom.xml
 buildNumber.properties
 .mvn/timing.properties
+out/
 
 
-### JetBrains template
-# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion
+### Java ###
+*.class
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.war
+*.ear
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+
+### Intellij ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
 
 *.iml
 
@@ -27,6 +51,7 @@ buildNumber.properties
 # .idea/workspace.xml
 # .idea/tasks.xml
 # .idea/dictionaries
+# .idea/shelf
 
 # Sensitive or high-churn files:
 # .idea/dataSources.ids
@@ -38,6 +63,7 @@ buildNumber.properties
 # Gradle:
 # .idea/gradle.xml
 # .idea/libraries
+.gradle
 
 # Mongo Explorer plugin:
 # .idea/mongoSettings.xml
@@ -61,23 +87,12 @@ atlassian-ide-plugin.xml
 com_crashlytics_export_strings.xml
 crashlytics.properties
 crashlytics-build.properties
+fabric.properties
 
 
-### NetBeans template
-nbproject/private/
-build/
-nbbuild/
-dist/
-nbdist/
-nbactions.xml
-nb-configuration.xml
-.nb-gradle/
-
-
-### Eclipse template
+### Eclipse ###
 *.pydevproject
 .metadata
-.gradle
 bin/
 tmp/
 *.tmp
@@ -115,20 +130,14 @@ local.properties
 # TeXlipse plugin
 .texlipse
 
-
-### Java template
-*.class
-
-# Mobile Tools for Java (J2ME)
-.mtj.tmp/
-
-# Package Files #
-*.jar
-*.war
-*.ear
-*.zip
-
-# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
-hs_err_pid*
-
-
+# STS (Spring Tool Suite)
+.springBeans
+/target/
+Nukkit/build/classes/
+Nukkit/build/dependency-cache/
+checkstyle.xml
+classes/
+p2error.txt
+*.bat
+Nukkit/build/resources/main/plugin.yml
+docs/

Bukkit/build.gradle

@@ -0,0 +1,104 @@
+plugins {
+    id "com.github.johnrengelman.shadow"
+}
+repositories {
+    maven { url = "https://hub.spigotmc.org/nexus/content/repositories/snapshots/" }
+    maven { url = "https://oss.sonatype.org/content/repositories/snapshots/" }
+    maven { url = "http://nexus.hc.to/content/repositories/pub_releases" }
+    maven { url = "https://repo.codemc.org/repository/maven-public" }
+    maven {
+        name = "papermc"
+        url = "https://papermc.io/repo/repository/maven-public/"
+    }
+    mavenLocal()
+}
+
+
+dependencies {
+    implementation(project(":Core"))
+    compile(project(":Core"))
+    compile("com.destroystokyo.paper:paper-api:1.14.4-R0.1-SNAPSHOT")
+    //implementation 'com.onarandombox.multiversecore:Multiverse-Core:3.0.0-SNAPSHOT'
+    implementation("org.spigotmc:spigot-api:1.15.2-R0.1-SNAPSHOT")
+    compile(group: "com.sk89q.worldedit", name: "worldedit-bukkit", version: "7.0.1")
+    compile("io.papermc:paperlib:1.0.2")
+    compile(group: "com.squareup.retrofit2", name: "retrofit", version: "2.4.0")
+    implementation("net.kyori:text-adapter-bukkit:3.0.3")
+    compile("net.milkbowl.vault:VaultAPI:1.7") {
+        exclude(module: "bukkit")
+    }
+}
+
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
+
+processResources {
+    from("src/main/resources") {
+        include("plugin.yml")
+        expand(
+                name: project.parent.name,
+                version: project.parent.version
+        )
+    }
+}
+
+//noinspection GroovyAssignabilityCheck
+jar.archiveFileName = "PlotSquared-BukkitAPI-${project.parent.version}.jar"
+jar.destinationDirectory = file("../mvn/com/github/intellectualsites/plotsquared/PlotSquared-BukkitAPI/" + project.parent.version)
+task createPom {
+    doLast {
+        pom {
+            project {
+                groupId = "com.github.intellectualsites.plotsquared"
+                artifactId = "PlotSquared-BukkitAPI"
+                version = project.parent.version
+            }
+        }.writeTo("../mvn/com/github/intellectualsites/plotsquared/PlotSquared-BukkitAPI/${project.parent.version}/PlotSquared-BukkitAPI-${project.parent.version}.pom")
+        pom {
+            project {
+                groupId = "com.github.intellectualsites.plotsquared"
+                artifactId = "PlotSquared-BukkitAPI"
+                version = "latest"
+            }
+        }.writeTo("../mvn/com/github/intellectualsites/plotsquared/PlotSquared-BukkitAPI/latest/PlotSquared-BukkitAPI-latest.pom")
+    }
+}
+
+task copyFiles {
+    doLast {
+        copy {
+            from("../mvn/com/github/intellectualsites/plotsquared/PlotSquared-BukkitAPI/${project.parent.version}/")
+            into("../mvn/com/github/intellectualsites/plotsquared/PlotSquared-BukkitAPI/latest/")
+            include("PlotSquared-BukkitAPI*.jar")
+            rename("PlotSquared-BukkitAPI-${project.parent.version}.jar", "PlotSquared-BukkitAPI-latest.jar")
+        }
+    }
+}
+
+
+shadowJar {
+    dependencies {
+        include(dependency(":Core"))
+        // update notification stuff
+        include(dependency("com.github.Sauilitired:Jenkins4J:2.0-SNAPSHOT"))
+        include(dependency("com.squareup.retrofit2:retrofit:2.4.0"))
+        include(dependency("com.squareup.okhttp3:okhttp:4.2.2"))
+        include(dependency("com.squareup.okio:okio:2.4.1"))
+        include(dependency("org.jetbrains.kotlin:kotlin-stdlib:1.3.61"))
+        include(dependency("io.papermc:paperlib:1.0.2"))
+        include(dependency("net.kyori:text-adapter-bukkit:3.0.3"))
+    }
+    relocate('net.kyori.text', 'com.github.intellectualsites.plotsquared.formatting.text')
+    relocate("io.papermc.lib", "com.github.intellectualsites.plotsquared.bukkit.paperlib")
+    archiveFileName = "${parent.name}-${project.name}-${parent.version}.jar"
+    destinationDirectory = file "../target"
+}
+
+shadowJar.doLast {
+    task ->
+        ant.checksum file: task.archivePath
+}
+
+build.dependsOn(shadowJar)
+build.finalizedBy(copyFiles)
+copyFiles.dependsOn(createPom)

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/BukkitMain.java

@@ -0,0 +1,848 @@
+package com.github.intellectualsites.plotsquared.bukkit;
+
+import com.github.intellectualsites.plotsquared.bukkit.generator.BukkitPlotGenerator;
+import com.github.intellectualsites.plotsquared.bukkit.listeners.ChunkListener;
+import com.github.intellectualsites.plotsquared.bukkit.listeners.EntitySpawnListener;
+import com.github.intellectualsites.plotsquared.bukkit.listeners.PlayerEvents;
+import com.github.intellectualsites.plotsquared.bukkit.listeners.PlotPlusListener;
+import com.github.intellectualsites.plotsquared.bukkit.listeners.SingleWorldListener;
+import com.github.intellectualsites.plotsquared.bukkit.listeners.WorldEvents;
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitChatManager;
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitChunkManager;
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitCommand;
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitEconHandler;
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitEventUtil;
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitHybridUtils;
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitInventoryUtil;
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitSchematicHandler;
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitSetupUtils;
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitTaskManager;
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitUtil;
+import com.github.intellectualsites.plotsquared.bukkit.util.Metrics;
+import com.github.intellectualsites.plotsquared.bukkit.util.SetGenCB;
+import com.github.intellectualsites.plotsquared.bukkit.util.block.BukkitLocalQueue;
+import com.github.intellectualsites.plotsquared.bukkit.uuid.DefaultUUIDWrapper;
+import com.github.intellectualsites.plotsquared.bukkit.uuid.FileUUIDHandler;
+import com.github.intellectualsites.plotsquared.bukkit.uuid.LowerOfflineUUIDWrapper;
+import com.github.intellectualsites.plotsquared.bukkit.uuid.OfflineUUIDWrapper;
+import com.github.intellectualsites.plotsquared.bukkit.uuid.SQLUUIDHandler;
+import com.github.intellectualsites.plotsquared.configuration.ConfigurationSection;
+import com.github.intellectualsites.plotsquared.plot.IPlotMain;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.config.Captions;
+import com.github.intellectualsites.plotsquared.plot.config.ConfigurationNode;
+import com.github.intellectualsites.plotsquared.plot.config.Settings;
+import com.github.intellectualsites.plotsquared.plot.generator.GeneratorWrapper;
+import com.github.intellectualsites.plotsquared.plot.generator.HybridGen;
+import com.github.intellectualsites.plotsquared.plot.generator.HybridUtils;
+import com.github.intellectualsites.plotsquared.plot.generator.IndependentPlotGenerator;
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.object.PlotArea;
+import com.github.intellectualsites.plotsquared.plot.object.PlotId;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.SetupObject;
+import com.github.intellectualsites.plotsquared.plot.object.chat.PlainChatManager;
+import com.github.intellectualsites.plotsquared.plot.object.worlds.PlotAreaManager;
+import com.github.intellectualsites.plotsquared.plot.object.worlds.SinglePlotArea;
+import com.github.intellectualsites.plotsquared.plot.object.worlds.SinglePlotAreaManager;
+import com.github.intellectualsites.plotsquared.plot.object.worlds.SingleWorldGenerator;
+import com.github.intellectualsites.plotsquared.plot.util.ChatManager;
+import com.github.intellectualsites.plotsquared.plot.util.ChunkManager;
+import com.github.intellectualsites.plotsquared.plot.util.ConsoleColors;
+import com.github.intellectualsites.plotsquared.plot.util.EconHandler;
+import com.github.intellectualsites.plotsquared.plot.util.EventUtil;
+import com.github.intellectualsites.plotsquared.plot.util.InventoryUtil;
+import com.github.intellectualsites.plotsquared.plot.util.MainUtil;
+import com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils;
+import com.github.intellectualsites.plotsquared.plot.util.SchematicHandler;
+import com.github.intellectualsites.plotsquared.plot.util.SetupUtils;
+import com.github.intellectualsites.plotsquared.plot.util.StringMan;
+import com.github.intellectualsites.plotsquared.plot.util.TaskManager;
+import com.github.intellectualsites.plotsquared.plot.util.UUIDHandler;
+import com.github.intellectualsites.plotsquared.plot.util.UUIDHandlerImplementation;
+import com.github.intellectualsites.plotsquared.plot.util.UpdateUtility;
+import com.github.intellectualsites.plotsquared.plot.util.WorldUtil;
+import com.github.intellectualsites.plotsquared.plot.util.block.QueueProvider;
+import com.github.intellectualsites.plotsquared.plot.uuid.UUIDWrapper;
+import com.sk89q.worldedit.WorldEdit;
+import com.sk89q.worldedit.bukkit.WorldEditPlugin;
+import com.sk89q.worldedit.extension.platform.Actor;
+import io.papermc.lib.PaperLib;
+import lombok.Getter;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Chunk;
+import org.bukkit.Location;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.World;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.command.PluginCommand;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.metadata.FixedMetadataValue;
+import org.bukkit.metadata.MetadataValue;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.lang.reflect.Method;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.getRefClass;
+
+public final class BukkitMain extends JavaPlugin implements Listener, IPlotMain {
+
+    @Getter private static WorldEdit worldEdit;
+
+    static {
+        try {
+            Settings.load(new File("plugins/PlotSquared/config/settings.yml"));
+        } catch (Throwable ignored) {
+        }
+    }
+
+    private int[] version;
+    @Getter private String pluginName;
+    @Getter private SingleWorldListener singleWorldListener;
+    private Method methodUnloadChunk0;
+    private boolean methodUnloadSetup = false;
+    private boolean metricsStarted;
+    private static final int BSTATS_ID = 1404;
+
+    @Override public int[] getServerVersion() {
+        if (this.version == null) {
+            try {
+                this.version = new int[3];
+                String[] split = Bukkit.getBukkitVersion().split("-")[0].split("\\.");
+                this.version[0] = Integer.parseInt(split[0]);
+                this.version[1] = Integer.parseInt(split[1]);
+                if (split.length == 3) {
+                    this.version[2] = Integer.parseInt(split[2]);
+                }
+            } catch (NumberFormatException e) {
+                e.printStackTrace();
+                PlotSquared.debug(StringMan.getString(Bukkit.getBukkitVersion()));
+                PlotSquared.debug(
+                    StringMan.getString(Bukkit.getBukkitVersion().split("-")[0].split("\\.")));
+                return new int[] {1, 13, 0};
+            }
+        }
+        return this.version;
+    }
+
+    @Override public String getServerImplementation() {
+        return Bukkit.getVersion();
+    }
+
+    @Override public void onEnable() {
+        this.pluginName = getDescription().getName();
+        PlotPlayer.registerConverter(Player.class, BukkitUtil::getPlayer);
+        PaperLib.suggestPaper(this);
+
+        new PlotSquared(this, "Bukkit");
+
+        if (PlotSquared.get().IMP.getServerVersion()[1] < 13) {
+            System.out.println(
+                "You can't use this version of PlotSquared on a server less than Minecraft 1.13.2.");
+            System.out
+                .println("Please check the download page for the link to the legacy versions.");
+            System.out.println("The server will now be shutdown to prevent any corruption.");
+            Bukkit.shutdown();
+            return;
+        }
+
+        // Check for updates
+        if (PlotSquared.get().getUpdateUtility() != null) {
+            final UpdateUtility updateUtility = PlotSquared.get().getUpdateUtility();
+            updateUtility.checkForUpdate(PlotSquared.get().getVersion().versionString(),
+                ((updateDescription, throwable) -> {
+                    Bukkit.getScheduler().runTask(BukkitMain.this, () -> {
+                        getLogger().info("-------- PlotSquared Update Check --------");
+                        if (throwable != null) {
+                            getLogger().severe(String
+                                .format("Could not check for updates. Reason: %s",
+                                    throwable.getMessage()));
+                        } else {
+                            if (updateDescription == null) {
+                                getLogger().info(
+                                    "You appear to be running the latest version of PlotSquared. Congratulations!");
+                            } else {
+                                getLogger()
+                                    .info("There appears to be a PlotSquared update available!");
+                                getLogger().info(String.format(
+                                    "You are running version %s, the newest available version is %s",
+                                    getPluginVersionString(), updateDescription.getVersion()));
+                                getLogger().info(
+                                    String.format("Update URL: %s", updateDescription.getUrl()));
+                            }
+                        }
+                        getLogger().info("-------- PlotSquared Update Check --------");
+                    });
+                }));
+        } else {
+            getLogger().warning("Update checking disabled. Skipping.");
+        }
+
+        this.startMetrics();
+        if (Settings.Enabled_Components.WORLDS) {
+            TaskManager.IMP.taskRepeat(this::unload, 20);
+            try {
+                singleWorldListener = new SingleWorldListener(this);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private void unload() {
+        if (!this.methodUnloadSetup) {
+            this.methodUnloadSetup = true;
+            try {
+                ReflectionUtils.RefClass classCraftWorld = getRefClass("{cb}.CraftWorld");
+                this.methodUnloadChunk0 = classCraftWorld.getRealClass()
+                    .getDeclaredMethod("unloadChunk0", int.class, int.class, boolean.class);
+                this.methodUnloadChunk0.setAccessible(true);
+            } catch (Throwable event) {
+                event.printStackTrace();
+            }
+        }
+        final PlotAreaManager manager = PlotSquared.get().getPlotAreaManager();
+        if (manager instanceof SinglePlotAreaManager) {
+            long start = System.currentTimeMillis();
+            final SinglePlotArea area = ((SinglePlotAreaManager) manager).getArea();
+
+            outer:
+            for (final World world : Bukkit.getWorlds()) {
+                final String name = world.getName();
+                final char char0 = name.charAt(0);
+                if (!Character.isDigit(char0) && char0 != '-') {
+                    continue;
+                }
+
+                if (!world.getPlayers().isEmpty()) {
+                    continue;
+                }
+
+                PlotId id;
+                try {
+                    id = PlotId.fromString(name);
+                } catch (IllegalArgumentException ignored) {
+                    continue;
+                }
+                final Plot plot = area.getOwnedPlot(id);
+                if (plot != null) {
+                    if (!MainUtil.isServerOwned(plot) || PlotPlayer.wrap(plot.getOwner()) == null) {
+                        if (world.getKeepSpawnInMemory()) {
+                            world.setKeepSpawnInMemory(false);
+                            return;
+                        }
+                        final Chunk[] chunks = world.getLoadedChunks();
+                        if (chunks.length == 0) {
+                            if (!Bukkit.unloadWorld(world, true)) {
+                                PlotSquared.debug("Failed to unload " + world.getName());
+                            }
+                            return;
+                        } else {
+                            int index = 0;
+                            do {
+                                final Chunk chunkI = chunks[index++];
+                                boolean result;
+                                if (methodUnloadChunk0 != null) {
+                                    try {
+                                        result = (boolean) methodUnloadChunk0
+                                            .invoke(world, chunkI.getX(), chunkI.getZ(), true);
+                                    } catch (Throwable e) {
+                                        methodUnloadChunk0 = null;
+                                        e.printStackTrace();
+                                        continue outer;
+                                    }
+                                } else {
+                                    result = world.unloadChunk(chunkI.getX(), chunkI.getZ(), true);
+                                }
+                                if (!result) {
+                                    continue outer;
+                                }
+                                if (System.currentTimeMillis() - start > 5) {
+                                    return;
+                                }
+                            } while (index < chunks.length);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Override public void onDisable() {
+        PlotSquared.get().disable();
+        Bukkit.getScheduler().cancelTasks(this);
+    }
+
+    @Override public void log(@NonNull String message) {
+        try {
+            message = Captions.color(message);
+            if (!Settings.Chat.CONSOLE_COLOR) {
+                message = ChatColor.stripColor(message);
+            }
+            this.getServer().getConsoleSender().sendMessage(message);
+        } catch (final Throwable ignored) {
+            System.out.println(ConsoleColors.fromString(message));
+        }
+    }
+
+    @Override public void shutdown() {
+        this.getServer().getPluginManager().disablePlugin(this);
+    }
+
+    @Override public int[] getPluginVersion() {
+        String ver = getDescription().getVersion();
+        if (ver.contains("-")) {
+            ver = ver.split("-")[0];
+        }
+        String[] split = ver.split("\\.");
+        return new int[] {Integer.parseInt(split[0]), Integer.parseInt(split[1]),
+            Integer.parseInt(split[2])};
+    }
+
+    @Override public String getPluginVersionString() {
+        return getDescription().getVersion();
+    }
+
+    @Override public void registerCommands() {
+        final BukkitCommand bukkitCommand = new BukkitCommand();
+        final PluginCommand plotCommand = getCommand("plots");
+        if (plotCommand != null) {
+            plotCommand.setExecutor(bukkitCommand);
+            plotCommand.setAliases(Arrays.asList("p", "ps", "plotme", "plot"));
+            plotCommand.setTabCompleter(bukkitCommand);
+        }
+    }
+
+    @Override public File getDirectory() {
+        return getDataFolder();
+    }
+
+    @Override public File getWorldContainer() {
+        return Bukkit.getWorldContainer();
+    }
+
+    @Override public TaskManager getTaskManager() {
+        return new BukkitTaskManager(this);
+    }
+
+    @Override @SuppressWarnings("deprecation") public void runEntityTask() {
+        PlotSquared.log(Captions.PREFIX + "KillAllEntities started.");
+        TaskManager.runTaskRepeat(() -> PlotSquared.get().forEachPlotArea(plotArea -> {
+            final World world = Bukkit.getWorld(plotArea.worldname);
+            try {
+                if (world == null) {
+                    return;
+                }
+                List<Entity> entities = world.getEntities();
+                Iterator<Entity> iterator = entities.iterator();
+                while (iterator.hasNext()) {
+                    Entity entity = iterator.next();
+                    switch (entity.getType()) {
+                        case EGG:
+                        case FISHING_HOOK:
+                        case ENDER_SIGNAL:
+                        case AREA_EFFECT_CLOUD:
+                        case EXPERIENCE_ORB:
+                        case LEASH_HITCH:
+                        case FIREWORK:
+                        case LIGHTNING:
+                        case WITHER_SKULL:
+                        case UNKNOWN:
+                        case PLAYER:
+                            // non moving / unmovable
+                            continue;
+                        case THROWN_EXP_BOTTLE:
+                        case SPLASH_POTION:
+                        case SNOWBALL:
+                        case SHULKER_BULLET:
+                        case SPECTRAL_ARROW:
+                        case ENDER_PEARL:
+                        case ARROW:
+                        case LLAMA_SPIT:
+                        case TRIDENT:
+                            // managed elsewhere | projectile
+                            continue;
+                        case ITEM_FRAME:
+                        case PAINTING:
+                            // Not vehicles
+                            continue;
+                        case ARMOR_STAND:
+                            // Temporarily classify as vehicle
+                        case MINECART:
+                        case MINECART_CHEST:
+                        case MINECART_COMMAND:
+                        case MINECART_FURNACE:
+                        case MINECART_HOPPER:
+                        case MINECART_MOB_SPAWNER:
+                        case ENDER_CRYSTAL:
+                        case MINECART_TNT:
+                        case BOAT:
+                            if (Settings.Enabled_Components.KILL_ROAD_VEHICLES) {
+                                com.github.intellectualsites.plotsquared.plot.object.Location
+                                    location = BukkitUtil.getLocation(entity.getLocation());
+                                Plot plot = location.getPlot();
+                                if (plot == null) {
+                                    if (location.isPlotArea()) {
+                                        if (entity.hasMetadata("ps-tmp-teleport")) {
+                                            continue;
+                                        }
+                                        iterator.remove();
+                                        entity.remove();
+                                    }
+                                    continue;
+                                }
+                                List<MetadataValue> meta = entity.getMetadata("plot");
+                                if (meta.isEmpty()) {
+                                    continue;
+                                }
+                                Plot origin = (Plot) meta.get(0).value();
+                                if (!plot.equals(origin.getBasePlot(false))) {
+                                    if (entity.hasMetadata("ps-tmp-teleport")) {
+                                        continue;
+                                    }
+                                    iterator.remove();
+                                    entity.remove();
+                                }
+                            }
+                            continue;
+                        case SMALL_FIREBALL:
+                        case FIREBALL:
+                        case DRAGON_FIREBALL:
+                        case DROPPED_ITEM:
+                            if (Settings.Enabled_Components.KILL_ROAD_ITEMS && plotArea
+                                .getOwnedPlotAbs(BukkitUtil.getLocation(entity.getLocation()))
+                                == null) {
+                                entity.remove();
+                            }
+                            // dropped item
+                            continue;
+                        case PRIMED_TNT:
+                        case FALLING_BLOCK:
+                            // managed elsewhere
+                            continue;
+                        case SHULKER:
+                            if (Settings.Enabled_Components.KILL_ROAD_MOBS) {
+                                LivingEntity livingEntity = (LivingEntity) entity;
+                                List<MetadataValue> meta = entity.getMetadata("shulkerPlot");
+                                if (!meta.isEmpty()) {
+                                    if (livingEntity.isLeashed()) {
+                                        continue;
+                                    }
+                                    List<MetadataValue> keep = entity.getMetadata("keep");
+                                    if (!keep.isEmpty()) {
+                                        continue;
+                                    }
+
+                                    PlotId originalPlotId = (PlotId) meta.get(0).value();
+                                    if (originalPlotId != null) {
+                                        com.github.intellectualsites.plotsquared.plot.object.Location
+                                            pLoc = BukkitUtil.getLocation(entity.getLocation());
+                                        PlotArea area = pLoc.getPlotArea();
+                                        if (area != null) {
+                                            PlotId currentPlotId = PlotId.of(area.getPlotAbs(pLoc));
+                                            if (!originalPlotId.equals(currentPlotId) && (
+                                                currentPlotId == null || !area
+                                                    .getPlot(originalPlotId)
+                                                    .equals(area.getPlot(currentPlotId)))) {
+                                                if (entity.hasMetadata("ps-tmp-teleport")) {
+                                                    continue;
+                                                }
+                                                iterator.remove();
+                                                entity.remove();
+                                            }
+                                        }
+                                    }
+                                } else {
+                                    //This is to apply the metadata to already spawned shulkers (see EntitySpawnListener.java)
+                                    com.github.intellectualsites.plotsquared.plot.object.Location
+                                        pLoc = BukkitUtil.getLocation(entity.getLocation());
+                                    PlotArea area = pLoc.getPlotArea();
+                                    if (area != null) {
+                                        PlotId currentPlotId = PlotId.of(area.getPlotAbs(pLoc));
+                                        if (currentPlotId != null) {
+                                            entity.setMetadata("shulkerPlot", new FixedMetadataValue(
+                                                (Plugin) PlotSquared.get().IMP, currentPlotId));
+                                        }
+                                    }
+                                }
+                            }
+                            continue;
+                        case LLAMA:
+                        case DONKEY:
+                        case MULE:
+                        case ZOMBIE_HORSE:
+                        case SKELETON_HORSE:
+                        case HUSK:
+                        case ELDER_GUARDIAN:
+                        case WITHER_SKELETON:
+                        case STRAY:
+                        case ZOMBIE_VILLAGER:
+                        case EVOKER:
+                        case EVOKER_FANGS:
+                        case VEX:
+                        case VINDICATOR:
+                        case POLAR_BEAR:
+                        case BAT:
+                        case BLAZE:
+                        case CAVE_SPIDER:
+                        case CHICKEN:
+                        case COW:
+                        case CREEPER:
+                        case ENDERMAN:
+                        case ENDERMITE:
+                        case ENDER_DRAGON:
+                        case GHAST:
+                        case GIANT:
+                        case GUARDIAN:
+                        case HORSE:
+                        case IRON_GOLEM:
+                        case MAGMA_CUBE:
+                        case MUSHROOM_COW:
+                        case OCELOT:
+                        case PIG:
+                        case PIG_ZOMBIE:
+                        case RABBIT:
+                        case SHEEP:
+                        case SILVERFISH:
+                        case SKELETON:
+                        case SLIME:
+                        case SNOWMAN:
+                        case SPIDER:
+                        case SQUID:
+                        case VILLAGER:
+                        case WITCH:
+                        case WITHER:
+                        case WOLF:
+                        case ZOMBIE:
+                        case PARROT:
+                        case SALMON:
+                        case DOLPHIN:
+                        case TROPICAL_FISH:
+                        case DROWNED:
+                        case COD:
+                        case TURTLE:
+                        case PUFFERFISH:
+                        case PHANTOM:
+                        case ILLUSIONER:
+                        case CAT:
+                        case PANDA:
+                        case FOX:
+                        case PILLAGER:
+                        case TRADER_LLAMA:
+                        case WANDERING_TRADER:
+                        case RAVAGER:
+                            //case BEE:
+                        default: {
+                            if (Settings.Enabled_Components.KILL_ROAD_MOBS) {
+                                Location location = entity.getLocation();
+                                if (BukkitUtil.getLocation(location).isPlotRoad()) {
+                                    if (entity instanceof LivingEntity) {
+                                        LivingEntity livingEntity = (LivingEntity) entity;
+                                        if (!livingEntity.isLeashed() || !entity
+                                            .hasMetadata("keep")) {
+                                            Entity passenger = entity.getPassenger();
+                                            if (!(passenger instanceof Player) && entity
+                                                .getMetadata("keep").isEmpty()) {
+                                                if (entity.hasMetadata("ps-tmp-teleport")) {
+                                                    continue;
+                                                }
+                                                iterator.remove();
+                                                entity.remove();
+                                                continue;
+                                            }
+                                        }
+                                    } else {
+                                        Entity passenger = entity.getPassenger();
+                                        if (!(passenger instanceof Player) && entity
+                                            .getMetadata("keep").isEmpty()) {
+                                            if (entity.hasMetadata("ps-tmp-teleport")) {
+                                                continue;
+                                            }
+                                            iterator.remove();
+                                            entity.remove();
+                                            continue;
+                                        }
+                                    }
+                                }
+                            }
+                            continue;
+                        }
+                    }
+                }
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        }), 20);
+    }
+
+    @Override @Nullable
+    public final ChunkGenerator getDefaultWorldGenerator(@NotNull final String worldName,
+        final String id) {
+        final IndependentPlotGenerator result;
+        if (id != null && id.equalsIgnoreCase("single")) {
+            result = new SingleWorldGenerator();
+        } else {
+            result = PlotSquared.get().IMP.getDefaultGenerator();
+            if (!PlotSquared.get().setupPlotWorld(worldName, id, result)) {
+                return null;
+            }
+        }
+        return (ChunkGenerator) result.specify(worldName);
+    }
+
+    @Override public void registerPlayerEvents() {
+        final PlayerEvents main = new PlayerEvents();
+        getServer().getPluginManager().registerEvents(main, this);
+        getServer().getPluginManager().registerEvents(new EntitySpawnListener(), this);
+    }
+
+    @Override public void registerPlotPlusEvents() {
+        PlotPlusListener.startRunnable(this);
+        getServer().getPluginManager().registerEvents(new PlotPlusListener(), this);
+    }
+
+    @Override public void registerForceFieldEvents() {
+    }
+
+    @Override public boolean initWorldEdit() {
+        if (getServer().getPluginManager().getPlugin("WorldEdit") != null) {
+            worldEdit = WorldEdit.getInstance();
+            return true;
+        }
+        return false;
+    }
+
+    @Override public EconHandler getEconomyHandler() {
+        try {
+            BukkitEconHandler econ = new BukkitEconHandler();
+            if (econ.init()) {
+                return econ;
+            }
+        } catch (Throwable ignored) {
+            PlotSquared.debug("No economy detected!");
+        }
+        return null;
+    }
+
+    @Override public QueueProvider initBlockQueue() {
+        //TODO Figure out why this code is still here yet isn't being called anywhere.
+        //        try {
+        //            new SendChunk();
+        //            MainUtil.canSendChunk = true;
+        //        } catch (ClassNotFoundException | NoSuchFieldException | NoSuchMethodException e) {
+        //            PlotSquared.debug(
+        //                SendChunk.class + " does not support " + StringMan.getString(getServerVersion()));
+        //            MainUtil.canSendChunk = false;
+        //        }
+        return QueueProvider.of(BukkitLocalQueue.class, BukkitLocalQueue.class);
+    }
+
+    @Override public WorldUtil initWorldUtil() {
+        return new BukkitUtil();
+    }
+
+    @Override @Nullable public GeneratorWrapper<?> getGenerator(@NonNull final String world,
+        @Nullable final String name) {
+        if (name == null) {
+            return null;
+        }
+        final Plugin genPlugin = Bukkit.getPluginManager().getPlugin(name);
+        if (genPlugin != null && genPlugin.isEnabled()) {
+            ChunkGenerator gen = genPlugin.getDefaultWorldGenerator(world, "");
+            if (gen instanceof GeneratorWrapper<?>) {
+                return (GeneratorWrapper<?>) gen;
+            }
+            return new BukkitPlotGenerator(world, gen);
+        } else {
+            return new BukkitPlotGenerator(PlotSquared.get().IMP.getDefaultGenerator());
+        }
+    }
+
+    @Override public HybridUtils initHybridUtils() {
+        return new BukkitHybridUtils();
+    }
+
+    @Override public SetupUtils initSetupUtils() {
+        return new BukkitSetupUtils();
+    }
+
+    @Deprecated
+    // Metrics are controlled via bstats config
+    @Override public void startMetrics() {
+        if (this.metricsStarted) {
+            return;
+        }
+        this.metricsStarted = true;
+        Metrics metrics = new Metrics(this, BSTATS_ID);// bstats
+        PlotSquared.log(Captions.PREFIX + "&6Metrics enabled.");
+    }
+
+    @Override public ChunkManager initChunkManager() {
+        return new BukkitChunkManager();
+    }
+
+    @Override public EventUtil initEventUtil() {
+        return new BukkitEventUtil();
+    }
+
+    @Override public void unregister(@NonNull final PlotPlayer player) {
+        BukkitUtil.removePlayer(player.getName());
+    }
+
+    @Override public void registerChunkProcessor() {
+        getServer().getPluginManager().registerEvents(new ChunkListener(), this);
+    }
+
+    @Override public void registerWorldEvents() {
+        getServer().getPluginManager().registerEvents(new WorldEvents(), this);
+    }
+
+    @NotNull @Override public IndependentPlotGenerator getDefaultGenerator() {
+        return new HybridGen();
+    }
+
+    @Override public InventoryUtil initInventoryUtil() {
+        return new BukkitInventoryUtil();
+    }
+
+    @Override public UUIDHandlerImplementation initUUIDHandler() {
+        final UUIDWrapper wrapper;
+        if (Settings.UUID.OFFLINE) {
+            if (Settings.UUID.FORCE_LOWERCASE) {
+                wrapper = new LowerOfflineUUIDWrapper();
+            } else {
+                wrapper = new OfflineUUIDWrapper();
+            }
+            Settings.UUID.OFFLINE = true;
+        } else {
+            wrapper = new DefaultUUIDWrapper();
+            Settings.UUID.OFFLINE = false;
+        }
+        if (!Bukkit.getVersion().contains("git-Spigot")) {
+            if (wrapper instanceof DefaultUUIDWrapper
+                || wrapper.getClass() == OfflineUUIDWrapper.class && !Bukkit.getOnlineMode()) {
+                Settings.UUID.NATIVE_UUID_PROVIDER = true;
+            }
+        }
+        if (Settings.UUID.OFFLINE) {
+            PlotSquared.log(Captions.PREFIX + "&6" + getPluginName()
+                + " is using Offline Mode UUIDs either because of user preference, or because you are using an old version of "
+                + "Bukkit");
+        } else {
+            PlotSquared.log(Captions.PREFIX + "&6" + getPluginName() + " is using online UUIDs");
+        }
+        if (Settings.UUID.USE_SQLUUIDHANDLER) {
+            return new SQLUUIDHandler(wrapper);
+        } else {
+            return new FileUUIDHandler(wrapper);
+        }
+    }
+
+    @Override public void setGenerator(@NonNull final String worldName) {
+        World world = BukkitUtil.getWorld(worldName);
+        if (world == null) {
+            // create world
+            ConfigurationSection worldConfig =
+                PlotSquared.get().worlds.getConfigurationSection("worlds." + worldName);
+            String manager = worldConfig.getString("generator.plugin", getPluginName());
+            SetupObject setup = new SetupObject();
+            setup.plotManager = manager;
+            setup.setupGenerator = worldConfig.getString("generator.init", manager);
+            setup.type = worldConfig.getInt("generator.type");
+            setup.terrain = worldConfig.getInt("generator.terrain");
+            setup.step = new ConfigurationNode[0];
+            setup.world = worldName;
+            SetupUtils.manager.setupWorld(setup);
+            world = Bukkit.getWorld(worldName);
+        } else {
+            try {
+                if (!PlotSquared.get().hasPlotArea(worldName)) {
+                    SetGenCB.setGenerator(BukkitUtil.getWorld(worldName));
+                }
+            } catch (Exception e) {
+                PlotSquared.log("Failed to reload world: " + world + " | " + e.getMessage());
+                Bukkit.getServer().unloadWorld(world, false);
+                return;
+            }
+        }
+        assert world != null;
+        ChunkGenerator gen = world.getGenerator();
+        if (gen instanceof BukkitPlotGenerator) {
+            PlotSquared.get().loadWorld(worldName, (BukkitPlotGenerator) gen);
+        } else if (gen != null) {
+            PlotSquared.get().loadWorld(worldName, new BukkitPlotGenerator(worldName, gen));
+        } else if (PlotSquared.get().worlds.contains("worlds." + worldName)) {
+            PlotSquared.get().loadWorld(worldName, null);
+        }
+    }
+
+    @Override public SchematicHandler initSchematicHandler() {
+        return new BukkitSchematicHandler();
+    }
+
+    @Override @Nullable public PlotPlayer wrapPlayer(final Object player) {
+        if (player instanceof Player) {
+            return BukkitUtil.getPlayer((Player) player);
+        }
+        if (player instanceof OfflinePlayer) {
+            return BukkitUtil.getPlayer((OfflinePlayer) player);
+        }
+        if (player instanceof String) {
+            return UUIDHandler.getPlayer((String) player);
+        }
+        if (player instanceof UUID) {
+            return UUIDHandler.getPlayer((UUID) player);
+        }
+        return null;
+    }
+
+    @Override public String getNMSPackage() {
+        final String name = Bukkit.getServer().getClass().getPackage().getName();
+        return name.substring(name.lastIndexOf('.') + 1);
+    }
+
+    @Override public ChatManager<?> initChatManager() {
+        if (Settings.Chat.INTERACTIVE) {
+            return new BukkitChatManager();
+        } else {
+            return new PlainChatManager();
+        }
+    }
+
+    @Override public GeneratorWrapper<?> wrapPlotGenerator(@Nullable final String world,
+        @NonNull final IndependentPlotGenerator generator) {
+        return new BukkitPlotGenerator(generator);
+    }
+
+    @Override public List<Map.Entry<Map.Entry<String, String>, Boolean>> getPluginIds() {
+        List<Map.Entry<Map.Entry<String, String>, Boolean>> names = new ArrayList<>();
+        for (final Plugin plugin : Bukkit.getPluginManager().getPlugins()) {
+            Map.Entry<String, String> id = new AbstractMap.SimpleEntry<>(plugin.getName(), plugin.getDescription().getVersion());
+            names.add(new AbstractMap.SimpleEntry<>(id, plugin.isEnabled()));
+        }
+        return names;
+    }
+
+    @Override public Actor getConsole() {
+        @NotNull ConsoleCommandSender console = Bukkit.getServer().getConsoleSender();
+        WorldEditPlugin wePlugin = ((WorldEditPlugin) Bukkit.getPluginManager().getPlugin("WorldEdit"));
+        return wePlugin.wrapCommandSender(console);
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/chat/ArrayWrapper.java

@@ -0,0 +1,107 @@
+package com.github.intellectualsites.plotsquared.bukkit.chat;
+
+import org.apache.commons.lang.Validate;
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.Collection;
+
+/**
+ * Represents a wrapper around an array class of an arbitrary reference type,
+ * which properly implements "value" hash code and equality functions.
+ * <p>
+ * This class is intended for use as a key to a map.
+ * </p>
+ *
+ * @param <E> The type of elements in the array.
+ * @author Glen Husman
+ * @see Arrays
+ */
+public final class ArrayWrapper<E> {
+
+    private E[] _array;
+
+    /**
+     * Creates an array wrapper with some elements.
+     *
+     * @param elements The elements of the array.
+     */
+    public ArrayWrapper(E... elements) {
+        setArray(elements);
+    }
+
+    /**
+     * Converts an iterable element collection to an array of elements.
+     * The iteration order of the specified object will be used as the array element order.
+     *
+     * @param list The iterable of objects which will be converted to an array.
+     * @param c    The type of the elements of the array.
+     * @return An array of elements in the specified iterable.
+     */
+    @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<? extends T> list,
+        Class<T> c) {
+        int size = -1;
+        if (list instanceof Collection<?>) {
+            @SuppressWarnings("rawtypes") Collection coll = (Collection) list;
+            size = coll.size();
+        }
+
+
+        if (size < 0) {
+            size = 0;
+            // Ugly hack: Count it ourselves
+            for (@SuppressWarnings("unused") T element : list) {
+                size++;
+            }
+        }
+
+        T[] result = (T[]) Array.newInstance(c, size);
+        int i = 0;
+        for (T element : list) { // Assumes iteration order is consistent
+            result[i++] = element; // Assign array element at index THEN increment counter
+        }
+        return result;
+    }
+
+    /**
+     * Retrieves a reference to the wrapped array instance.
+     *
+     * @return The array wrapped by this instance.
+     */
+    public E[] getArray() {
+        return _array;
+    }
+
+    /**
+     * Set this wrapper to wrap a new array instance.
+     *
+     * @param array The new wrapped array.
+     */
+    public void setArray(E[] array) {
+        Validate.notNull(array, "The array must not be null.");
+        _array = array;
+    }
+
+    /**
+     * Determines if this object has a value equivalent to another object.
+     *
+     * @see Arrays#equals(Object[], Object[])
+     */
+    @SuppressWarnings("rawtypes") @Override public boolean equals(Object other) {
+        if (!(other instanceof ArrayWrapper)) {
+            return false;
+        }
+        return Arrays.equals(_array, ((ArrayWrapper) other)._array);
+    }
+
+    /**
+     * Gets the hash code represented by this objects value.
+     *
+     * @return This object's hash code.
+     * @see Arrays#hashCode(Object[])
+     */
+    @Override public int hashCode() {
+        return Arrays.hashCode(_array);
+    }
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/chat/FancyMessage.java

@@ -0,0 +1,905 @@
+package com.github.intellectualsites.plotsquared.bukkit.chat;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.google.gson.stream.JsonWriter;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.Statistic;
+import org.bukkit.Statistic.Type;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+
+/**
+ * Represents a formattable message. Such messages can use elements such as colors, formatting codes, hover and click data, and other features provided by the vanilla Minecraft <a href="http://minecraft.gamepedia.com/Tellraw#Raw_JSON_Text">JSON message formatter</a>.
+ * This class allows plugins to emulate the functionality of the vanilla Minecraft <a href="http://minecraft.gamepedia.com/Commands#tellraw">tellraw command</a>.
+ * <p>
+ * This class follows the builder pattern, allowing for method chaining.
+ * It is set up such that invocations of property-setting methods will affect the current editing component,
+ * and a call to {@link #then()} or {@link #then(String)} will append a new editing component to the end of the message,
+ * optionally initializing it with text. Further property-setting method calls will affect that editing component.
+ * </p>
+ */
+public class FancyMessage
+    implements JsonRepresentedObject, Cloneable, Iterable<MessagePart>, ConfigurationSerializable {
+
+    private static Constructor<?> nmsPacketPlayOutChatConstructor;
+    // The ChatSerializer's instance of Gson
+    private static Object nmsChatSerializerGsonInstance;
+    private static Method fromJsonMethod;
+    private static JsonParser _stringParser = new JsonParser();
+
+    static {
+        ConfigurationSerialization.registerClass(FancyMessage.class);
+    }
+
+    private List<MessagePart> messageParts;
+    private String jsonString;
+    private boolean dirty;
+
+    /**
+     * Creates a JSON message with text.
+     *
+     * @param firstPartText The existing text in the message.
+     */
+    public FancyMessage(final String firstPartText) {
+        this(TextualComponent.rawText(firstPartText));
+    }
+
+    private FancyMessage(final TextualComponent firstPartText) {
+        messageParts = new ArrayList<>();
+        messageParts.add(new MessagePart(firstPartText));
+        jsonString = null;
+        dirty = false;
+        if (nmsPacketPlayOutChatConstructor == null) {
+            try {
+                nmsPacketPlayOutChatConstructor = Reflection.getNMSClass("PacketPlayOutChat")
+                    .getDeclaredConstructor(Reflection.getNMSClass("IChatBaseComponent"));
+                nmsPacketPlayOutChatConstructor.setAccessible(true);
+            } catch (NoSuchMethodException e) {
+                Bukkit.getLogger()
+                    .log(Level.SEVERE, "Could not find Minecraft method or constructor.", e);
+            } catch (SecurityException e) {
+                Bukkit.getLogger().log(Level.WARNING, "Could not access constructor.", e);
+            }
+        }
+    }
+
+    /**
+     * Creates a JSON message without text.
+     */
+    public FancyMessage() {
+        this((TextualComponent) null);
+    }
+
+    /**
+     * Deserializes a JSON-represented message from a mapping of key-value pairs.
+     * This is called by the Bukkit serialization API.
+     * It is not intended for direct public API consumption.
+     *
+     * @param serialized The key-value mapping which represents a fancy message.
+     */
+    @SuppressWarnings("unchecked") public static FancyMessage deserialize(
+        Map<String, Object> serialized) {
+        FancyMessage msg = new FancyMessage();
+        msg.messageParts = (List<MessagePart>) serialized.get("messageParts");
+        msg.jsonString = serialized.containsKey("JSON") ? serialized.get("JSON").toString() : null;
+        msg.dirty = !serialized.containsKey("JSON");
+        return msg;
+    }
+
+    /**
+     * Deserializes a fancy message from its JSON representation. This JSON representation is of the format of
+     * that returned by {@link #toJSONString()}, and is compatible with vanilla inputs.
+     *
+     * @param json The JSON string which represents a fancy message.
+     * @return A {@code FancyMessage} representing the parameterized JSON message.
+     */
+    public static FancyMessage deserialize(String json) {
+        JsonObject serialized = _stringParser.parse(json).getAsJsonObject();
+        JsonArray extra = serialized.getAsJsonArray("extra"); // Get the extra component
+        FancyMessage returnVal = new FancyMessage();
+        returnVal.messageParts.clear();
+        for (JsonElement mPrt : extra) {
+            MessagePart component = new MessagePart();
+            JsonObject messagePart = mPrt.getAsJsonObject();
+            for (Map.Entry<String, JsonElement> entry : messagePart.entrySet()) {
+                // Deserialize text
+                if (TextualComponent.isTextKey(entry.getKey())) {
+                    // The map mimics the YAML serialization, which has a "key" field and one or more "value" fields
+                    Map<String, Object> serializedMapForm =
+                        new HashMap<>(); // Must be object due to Bukkit serializer API compliance
+                    serializedMapForm.put("key", entry.getKey());
+                    if (entry.getValue().isJsonPrimitive()) {
+                        // Assume string
+                        serializedMapForm.put("value", entry.getValue().getAsString());
+                    } else {
+                        // Composite object, but we assume each element is a string
+                        for (Map.Entry<String, JsonElement> compositeNestedElement : entry
+                            .getValue().getAsJsonObject().entrySet()) {
+                            serializedMapForm.put("value." + compositeNestedElement.getKey(),
+                                compositeNestedElement.getValue().getAsString());
+                        }
+                    }
+                    component.text = TextualComponent.deserialize(serializedMapForm);
+                } else if (MessagePart.stylesToNames.inverse().containsKey(entry.getKey())) {
+                    if (entry.getValue().getAsBoolean()) {
+                        component.styles
+                            .add(MessagePart.stylesToNames.inverse().get(entry.getKey()));
+                    }
+                } else if (entry.getKey().equals("color")) {
+                    component.color =
+                        ChatColor.valueOf(entry.getValue().getAsString().toUpperCase());
+                } else if (entry.getKey().equals("clickEvent")) {
+                    JsonObject object = entry.getValue().getAsJsonObject();
+                    component.clickActionName = object.get("action").getAsString();
+                    component.clickActionData = object.get("value").getAsString();
+                } else if (entry.getKey().equals("hoverEvent")) {
+                    JsonObject object = entry.getValue().getAsJsonObject();
+                    component.hoverActionName = object.get("action").getAsString();
+                    if (object.get("value").isJsonPrimitive()) {
+                        // Assume string
+                        component.hoverActionData =
+                            new JsonString(object.get("value").getAsString());
+                    } else {
+                        // Assume composite type
+                        // The only composite type we currently store is another FancyMessage
+                        // Therefore, recursion time!
+                        component.hoverActionData = deserialize(object.get("value")
+                            .toString() /* This should properly serialize the JSON object as a JSON string */);
+                    }
+                } else if (entry.getKey().equals("insertion")) {
+                    component.insertionData = entry.getValue().getAsString();
+                } else if (entry.getKey().equals("with")) {
+                    for (JsonElement object : entry.getValue().getAsJsonArray()) {
+                        if (object.isJsonPrimitive()) {
+                            component.translationReplacements
+                                .add(new JsonString(object.getAsString()));
+                        } else {
+                            // Only composite type stored in this array is - again - FancyMessages
+                            // Recurse within this function to parse this as a translation replacement
+                            component.translationReplacements.add(deserialize(object.toString()));
+                        }
+                    }
+                }
+            }
+            returnVal.messageParts.add(component);
+        }
+        return returnVal;
+    }
+
+    @Override public FancyMessage clone() throws CloneNotSupportedException {
+        FancyMessage instance = (FancyMessage) super.clone();
+        instance.messageParts = new ArrayList<>(messageParts.size());
+        for (int i = 0; i < messageParts.size(); i++) {
+            instance.messageParts.add(i, messageParts.get(i).clone());
+        }
+        instance.dirty = false;
+        instance.jsonString = null;
+        return instance;
+    }
+
+    /**
+     * Sets the text of the current editing component to a value.
+     *
+     * @param text The new text of the current editing component.
+     * @return This builder instance.
+     */
+    public FancyMessage text(String text) {
+        MessagePart latest = latest();
+        latest.text = TextualComponent.rawText(text);
+        dirty = true;
+        return this;
+    }
+
+    /**
+     * Sets the text of the current editing component to a value.
+     *
+     * @param text The new text of the current editing component.
+     * @return This builder instance.
+     */
+    public FancyMessage text(TextualComponent text) {
+        MessagePart latest = latest();
+        latest.text = text;
+        dirty = true;
+        return this;
+    }
+
+    /**
+     * Sets the color of the current editing component to a value.
+     *
+     * @param color The new color of the current editing component.
+     * @return This builder instance.
+     * @throws IllegalArgumentException If the specified {@code ChatColor} enumeration value is not a color (but a format value).
+     */
+    public FancyMessage color(final ChatColor color) {
+        if (!color.isColor()) {
+            throw new IllegalArgumentException(color.name() + " is not a color");
+        }
+        latest().color = color;
+        dirty = true;
+        return this;
+    }
+
+    /**
+     * Sets the stylization of the current editing component.
+     *
+     * @param styles The array of styles to apply to the editing component.
+     * @return This builder instance.
+     * @throws IllegalArgumentException If any of the enumeration values in the array do not represent formatters.
+     */
+    public FancyMessage style(ChatColor... styles) {
+        for (final ChatColor style : styles) {
+            if (!style.isFormat()) {
+                throw new IllegalArgumentException(style.name() + " is not a style");
+            }
+        }
+        latest().styles.addAll(Arrays.asList(styles));
+        dirty = true;
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to instruct the client to open a file on the client side filesystem when the currently edited part of the {@code FancyMessage} is clicked.
+     *
+     * @param path The path of the file on the client filesystem.
+     * @return This builder instance.
+     */
+    public FancyMessage file(final String path) {
+        onClick("open_file", path);
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to instruct the client to open a webpage in the client's web browser when the currently edited part of the {@code FancyMessage} is clicked.
+     *
+     * @param url The URL of the page to open when the link is clicked.
+     * @return This builder instance.
+     */
+    public FancyMessage link(final String url) {
+        onClick("open_url", url);
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to instruct the client to replace the chat input box content with the specified string when the currently edited part of the {@code FancyMessage} is clicked.
+     * The client will not immediately send the command to the server to be executed unless the client player submits the command/chat message, usually with the enter key.
+     *
+     * @param command The text to display in the chat bar of the client.
+     * @return This builder instance.
+     */
+    public FancyMessage suggest(final String command) {
+        onClick("suggest_command", command);
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to instruct the client to append the chat input box content with the specified string when the currently edited part of the {@code FancyMessage} is SHIFT-CLICKED.
+     * The client will not immediately send the command to the server to be executed unless the client player submits the command/chat message, usually with the enter key.
+     *
+     * @param command The text to append to the chat bar of the client.
+     * @return This builder instance.
+     */
+    public FancyMessage insert(final String command) {
+        latest().insertionData = command;
+        dirty = true;
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to instruct the client to send the specified string to the server as a chat message when the currently edited part of the {@code FancyMessage} is clicked.
+     * The client <b>will</b> immediately send the command to the server to be executed when the editing component is clicked.
+     *
+     * @param command The text to display in the chat bar of the client.
+     * @return This builder instance.
+     */
+    public FancyMessage command(final String command) {
+        onClick("run_command", command);
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to display information about an achievement when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param name The name of the achievement to display, excluding the "achievement." prefix.
+     * @return This builder instance.
+     */
+    public FancyMessage achievementTooltip(final String name) {
+        onHover("show_achievement", new JsonString("achievement." + name));
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to display information about a parameterless statistic when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param which The statistic to display.
+     * @return This builder instance.
+     * @throws IllegalArgumentException If the statistic requires a parameter which was not supplied.
+     */
+    public FancyMessage statisticTooltip(final Statistic which) {
+        Type type = which.getType();
+        if (type != Type.UNTYPED) {
+            throw new IllegalArgumentException(
+                "That statistic requires an additional " + type + " parameter!");
+        }
+        try {
+            Object statistic = Reflection
+                .getMethod(Reflection.getOBCClass("CraftStatistic"), "getNMSStatistic",
+                    Statistic.class).invoke(null, which);
+            return achievementTooltip(
+                (String) Reflection.getField(Reflection.getNMSClass("Statistic"), "name")
+                    .get(statistic));
+        } catch (IllegalAccessException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Could not access method.", e);
+            return this;
+        } catch (IllegalArgumentException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Argument could not be passed.", e);
+            return this;
+        } catch (InvocationTargetException e) {
+            Bukkit.getLogger()
+                .log(Level.WARNING, "A error has occurred during invoking of method.", e);
+            return this;
+        }
+    }
+
+    /**
+     * Set the behavior of the current editing component to display information about a statistic parameter with a material when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param which The statistic to display.
+     * @param item  The sole material parameter to the statistic.
+     * @return This builder instance.
+     * @throws IllegalArgumentException If the statistic requires a parameter which was not supplied, or was supplied a parameter that was not required.
+     */
+    public FancyMessage statisticTooltip(final Statistic which, Material item) {
+        Type type = which.getType();
+        if (type == Type.UNTYPED) {
+            throw new IllegalArgumentException("That statistic needs no additional parameter!");
+        }
+        if ((type == Type.BLOCK && item.isBlock()) || type == Type.ENTITY) {
+            throw new IllegalArgumentException(
+                "Wrong parameter type for that statistic - needs " + type + "!");
+        }
+        try {
+            Object statistic = Reflection
+                .getMethod(Reflection.getOBCClass("CraftStatistic"), "getMaterialStatistic",
+                    Statistic.class, Material.class).invoke(null, which, item);
+            return achievementTooltip(
+                (String) Reflection.getField(Reflection.getNMSClass("Statistic"), "name")
+                    .get(statistic));
+        } catch (IllegalAccessException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Could not access method.", e);
+            return this;
+        } catch (IllegalArgumentException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Argument could not be passed.", e);
+            return this;
+        } catch (InvocationTargetException e) {
+            Bukkit.getLogger()
+                .log(Level.WARNING, "A error has occurred during invoking of method.", e);
+            return this;
+        }
+    }
+
+    /**
+     * Set the behavior of the current editing component to display information about a statistic parameter with an entity type when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param which  The statistic to display.
+     * @param entity The sole entity type parameter to the statistic.
+     * @return This builder instance.
+     * @throws IllegalArgumentException If the statistic requires a parameter which was not supplied, or was supplied a parameter that was not required.
+     */
+    public FancyMessage statisticTooltip(final Statistic which, EntityType entity) {
+        Type type = which.getType();
+        if (type == Type.UNTYPED) {
+            throw new IllegalArgumentException("That statistic needs no additional parameter!");
+        }
+        if (type != Type.ENTITY) {
+            throw new IllegalArgumentException(
+                "Wrong parameter type for that statistic - needs " + type + "!");
+        }
+        try {
+            Object statistic = Reflection
+                .getMethod(Reflection.getOBCClass("CraftStatistic"), "getEntityStatistic",
+                    Statistic.class, EntityType.class).invoke(null, which, entity);
+            return achievementTooltip(
+                (String) Reflection.getField(Reflection.getNMSClass("Statistic"), "name")
+                    .get(statistic));
+        } catch (IllegalAccessException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Could not access method.", e);
+            return this;
+        } catch (IllegalArgumentException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Argument could not be passed.", e);
+            return this;
+        } catch (InvocationTargetException e) {
+            Bukkit.getLogger()
+                .log(Level.WARNING, "A error has occurred during invoking of method.", e);
+            return this;
+        }
+    }
+
+    /**
+     * Set the behavior of the current editing component to display information about an item when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param itemJSON A string representing the JSON-serialized NBT data tag of an {@link ItemStack}.
+     * @return This builder instance.
+     */
+    public FancyMessage itemTooltip(final String itemJSON) {
+        onHover("show_item", new JsonString(
+            itemJSON)); // Seems a bit hacky, considering we have a JSON object as a parameter
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to display information about an item when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param itemStack The stack for which to display information.
+     * @return This builder instance.
+     */
+    public FancyMessage itemTooltip(final ItemStack itemStack) {
+        try {
+            Object nmsItem = Reflection
+                .getMethod(Reflection.getOBCClass("inventory.CraftItemStack"), "asNMSCopy",
+                    ItemStack.class).invoke(null, itemStack);
+            return itemTooltip(Reflection.getMethod(Reflection.getNMSClass("ItemStack"), "save",
+                Reflection.getNMSClass("NBTTagCompound"))
+                .invoke(nmsItem, Reflection.getNMSClass("NBTTagCompound").newInstance())
+                .toString());
+        } catch (Exception e) {
+            e.printStackTrace();
+            return this;
+        }
+    }
+
+    /**
+     * Set the behavior of the current editing component to display raw text when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param text The text, which supports newlines, which will be displayed to the client upon hovering.
+     * @return This builder instance.
+     */
+    public FancyMessage tooltip(final String text) {
+        onHover("show_text", new JsonString(text));
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to display raw text when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param lines The lines of text which will be displayed to the client upon hovering. The iteration order of this object will be the order in which the lines of the tooltip are created.
+     * @return This builder instance.
+     */
+    public FancyMessage tooltip(final Iterable<String> lines) {
+        tooltip(ArrayWrapper.toArray(lines, String.class));
+        return this;
+    }
+    /*
+
+    /**
+     * If the text is a translatable key, and it has replaceable values, this function can be used to set the replacements that will be used in the message.
+     * @param replacements The replacements, in order, that will be used in the language-specific message.
+     * @return This builder instance.
+     */   /* ------------
+    public FancyMessage translationReplacements(final Iterable<? extends CharSequence> replacements){
+        for(CharSequence str : replacements){
+            latest().translationReplacements.add(new JsonString(str));
+        }
+
+        return this;
+    }
+
+    */
+
+    /**
+     * Set the behavior of the current editing component to display raw text when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param lines The lines of text which will be displayed to the client upon hovering.
+     * @return This builder instance.
+     */
+    public FancyMessage tooltip(final String... lines) {
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < lines.length; i++) {
+            builder.append(lines[i]);
+            if (i != lines.length - 1) {
+                builder.append('\n');
+            }
+        }
+        tooltip(builder.toString());
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to display formatted text when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param text The formatted text which will be displayed to the client upon hovering.
+     * @return This builder instance.
+     */
+    public FancyMessage formattedTooltip(FancyMessage text) {
+        for (MessagePart component : text.messageParts) {
+            if (component.clickActionData != null && component.clickActionName != null) {
+                throw new IllegalArgumentException("The tooltip text cannot have click data.");
+            } else if (component.hoverActionData != null && component.hoverActionName != null) {
+                throw new IllegalArgumentException("The tooltip text cannot have a tooltip.");
+            }
+        }
+        onHover("show_text", text);
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to display the specified lines of formatted text when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param lines The lines of formatted text which will be displayed to the client upon hovering.
+     * @return This builder instance.
+     */
+    public FancyMessage formattedTooltip(FancyMessage... lines) {
+        if (lines.length < 1) {
+            onHover(null, null); // Clear tooltip
+            return this;
+        }
+
+        FancyMessage result = new FancyMessage();
+        result.messageParts
+            .clear(); // Remove the one existing text component that exists by default, which destabilizes the object
+
+        for (int i = 0; i < lines.length; i++) {
+            try {
+                for (MessagePart component : lines[i]) {
+                    if (component.clickActionData != null && component.clickActionName != null) {
+                        throw new IllegalArgumentException(
+                            "The tooltip text cannot have click data.");
+                    } else if (component.hoverActionData != null
+                        && component.hoverActionName != null) {
+                        throw new IllegalArgumentException(
+                            "The tooltip text cannot have a tooltip.");
+                    }
+                    if (component.hasText()) {
+                        result.messageParts.add(component.clone());
+                    }
+                }
+                if (i != lines.length - 1) {
+                    result.messageParts.add(new MessagePart(TextualComponent.rawText("\n")));
+                }
+            } catch (CloneNotSupportedException e) {
+                Bukkit.getLogger().log(Level.WARNING, "Failed to clone object", e);
+                return this;
+            }
+        }
+        return formattedTooltip(
+            result.messageParts.isEmpty() ? null : result); // Throws NPE if size is 0, intended
+    }
+
+    /**
+     * Set the behavior of the current editing component to display the specified lines of formatted text when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param lines The lines of text which will be displayed to the client upon hovering. The iteration order of this object will be the order in which the lines of the tooltip are created.
+     * @return This builder instance.
+     */
+    public FancyMessage formattedTooltip(final Iterable<FancyMessage> lines) {
+        return formattedTooltip(ArrayWrapper.toArray(lines, FancyMessage.class));
+    }
+
+    /**
+     * If the text is a translatable key, and it has replaceable values, this function can be used to set the replacements that will be used in the message.
+     *
+     * @param replacements The replacements, in order, that will be used in the language-specific message.
+     * @return This builder instance.
+     */
+    public FancyMessage translationReplacements(final String... replacements) {
+        for (String str : replacements) {
+            latest().translationReplacements.add(new JsonString(str));
+        }
+        dirty = true;
+
+        return this;
+    }
+
+    /**
+     * If the text is a translatable key, and it has replaceable values, this function can be used to set the replacements that will be used in the message.
+     *
+     * @param replacements The replacements, in order, that will be used in the language-specific message.
+     * @return This builder instance.
+     */
+    public FancyMessage translationReplacements(final FancyMessage... replacements) {
+        Collections.addAll(latest().translationReplacements, replacements);
+
+        dirty = true;
+
+        return this;
+    }
+
+    /**
+     * If the text is a translatable key, and it has replaceable values, this function can be used to set the replacements that will be used in the message.
+     *
+     * @param replacements The replacements, in order, that will be used in the language-specific message.
+     * @return This builder instance.
+     */
+    public FancyMessage translationReplacements(final Iterable<FancyMessage> replacements) {
+        return translationReplacements(ArrayWrapper.toArray(replacements, FancyMessage.class));
+    }
+
+    /**
+     * Terminate construction of the current editing component, and begin construction of a new message component.
+     * After a successful call to this method, all setter methods will refer to a new message component, created as a result of the call to this method.
+     *
+     * @param text The text which will populate the new message component.
+     * @return This builder instance.
+     */
+    public FancyMessage then(final String text) {
+        return then(TextualComponent.rawText(text));
+    }
+
+    /**
+     * Terminate construction of the current editing component, and begin construction of a new message component.
+     * After a successful call to this method, all setter methods will refer to a new message component, created as a result of the call to this method.
+     *
+     * @param text The text which will populate the new message component.
+     * @return This builder instance.
+     */
+    public FancyMessage then(final TextualComponent text) {
+        if (!latest().hasText()) {
+            throw new IllegalStateException("previous message part has no text");
+        }
+        messageParts.add(new MessagePart(text));
+        dirty = true;
+        return this;
+    }
+
+    /**
+     * Terminate construction of the current editing component, and begin construction of a new message component.
+     * After a successful call to this method, all setter methods will refer to a new message component, created as a result of the call to this method.
+     *
+     * @return This builder instance.
+     */
+    public FancyMessage then() {
+        if (!latest().hasText()) {
+            throw new IllegalStateException("previous message part has no text");
+        }
+        messageParts.add(new MessagePart());
+        dirty = true;
+        return this;
+    }
+
+    @Override public void writeJson(JsonWriter writer) throws IOException {
+        if (messageParts.size() == 1) {
+            latest().writeJson(writer);
+        } else {
+            writer.beginObject().name("text").value("").name("extra").beginArray();
+            for (final MessagePart part : this) {
+                part.writeJson(writer);
+            }
+            writer.endArray().endObject();
+        }
+    }
+
+    /**
+     * Serialize this fancy message, converting it into syntactically-valid JSON using a {@link JsonWriter}.
+     * This JSON should be compatible with vanilla formatter commands such as {@code /tellraw}.
+     *
+     * @return The JSON string representing this object.
+     */
+    public String toJSONString() {
+        if (!dirty && jsonString != null) {
+            return jsonString;
+        }
+        StringWriter string = new StringWriter();
+        JsonWriter json = new JsonWriter(string);
+        try {
+            writeJson(json);
+            json.close();
+        } catch (IOException e) {
+            throw new RuntimeException("invalid message");
+        }
+        jsonString = string.toString();
+        dirty = false;
+        return jsonString;
+    }
+
+    /**
+     * Sends this message to a player. The player will receive the fully-fledged formatted display of this message.
+     *
+     * @param player The player who will receive the message.
+     */
+    public void send(Player player) {
+        send(player, toJSONString());
+    }
+
+    private void send(CommandSender sender, String jsonString) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(toOldMessageFormat());
+            return;
+        }
+        Player player = (Player) sender;
+        try {
+            Object handle = Reflection.getHandle(player);
+            Object connection =
+                Reflection.getField(handle.getClass(), "playerConnection").get(handle);
+            Reflection
+                .getMethod(connection.getClass(), "sendPacket", Reflection.getNMSClass("Packet"))
+                .invoke(connection, createChatPacket(jsonString));
+        } catch (IllegalArgumentException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Argument could not be passed.", e);
+        } catch (IllegalAccessException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Could not access method.", e);
+        } catch (InstantiationException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Underlying class is abstract.", e);
+        } catch (InvocationTargetException e) {
+            Bukkit.getLogger()
+                .log(Level.WARNING, "A error has occurred during invoking of method.", e);
+        } catch (NoSuchMethodException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Could not find method.", e);
+        } catch (ClassNotFoundException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Could not find class.", e);
+        }
+    }
+
+    private Object createChatPacket(String json)
+        throws IllegalArgumentException, IllegalAccessException, InstantiationException,
+        InvocationTargetException, NoSuchMethodException, ClassNotFoundException {
+        if (nmsChatSerializerGsonInstance == null) {
+            // Find the field and its value, completely bypassing obfuscation
+            Class<?> chatSerializerClazz;
+
+            // Get the three parts of the version string (major version is currently unused)
+            // vX_Y_RZ
+            //   X = major
+            //   Y = minor
+            //   Z = revision
+            final String version = Reflection.getVersion();
+            String[] split =
+                version.substring(1, version.length() - 1).split("_"); // Remove trailing dot
+            //int majorVersion = Integer.parseInt(split[0]);
+            int minorVersion = Integer.parseInt(split[1]);
+            int revisionVersion = Integer.parseInt(split[2].substring(1)); // Substring to ignore R
+
+            if (minorVersion < 8 || (minorVersion == 8 && revisionVersion == 1)) {
+                chatSerializerClazz = Reflection.getNMSClass("ChatSerializer");
+            } else {
+                chatSerializerClazz = Reflection.getNMSClass("IChatBaseComponent$ChatSerializer");
+            }
+
+            if (chatSerializerClazz == null) {
+                throw new ClassNotFoundException("Can't find the ChatSerializer class");
+            }
+
+            for (Field declaredField : chatSerializerClazz.getDeclaredFields()) {
+                if (Modifier.isFinal(declaredField.getModifiers()) && Modifier
+                    .isStatic(declaredField.getModifiers()) && declaredField.getType().getName()
+                    .endsWith("Gson")) {
+                    // We've found our field
+                    declaredField.setAccessible(true);
+                    nmsChatSerializerGsonInstance = declaredField.get(null);
+                    fromJsonMethod = nmsChatSerializerGsonInstance.getClass()
+                        .getMethod("fromJson", String.class, Class.class);
+                    break;
+                }
+            }
+        }
+
+        // Since the method is so simple, and all the obfuscated methods have the same name, it's easier to reimplement 'IChatBaseComponent a(String)' than to reflectively call it
+        // Of course, the implementation may change, but fuzzy matches might break with signature changes
+        Object serializedChatComponent = fromJsonMethod.invoke(nmsChatSerializerGsonInstance, json,
+            Reflection.getNMSClass("IChatBaseComponent"));
+
+        return nmsPacketPlayOutChatConstructor.newInstance(serializedChatComponent);
+    }
+
+    /**
+     * Sends this message to a command sender.
+     * If the sender is a player, they will receive the fully-fledged formatted display of this message.
+     * Otherwise, they will receive a version of this message with less formatting.
+     *
+     * @param sender The command sender who will receive the message.
+     * @see #toOldMessageFormat()
+     */
+    public void send(CommandSender sender) {
+        send(sender, toJSONString());
+    }
+
+    /**
+     * Sends this message to multiple command senders.
+     *
+     * @param senders The command senders who will receive the message.
+     * @see #send(CommandSender)
+     */
+    public void send(final Iterable<? extends CommandSender> senders) {
+        String string = toJSONString();
+        for (final CommandSender sender : senders) {
+            send(sender, string);
+        }
+    }
+
+    /**
+     * Convert this message to a human-readable string with limited formatting.
+     * This method is used to send this message to clients without JSON formatting support.
+     * <p>
+     * Serialization of this message by using this message will include (in this order for each message part):
+     * <ol>
+     * <li>The color of each message part.</li>
+     * <li>The applicable stylizations for each message part.</li>
+     * <li>The core text of the message part.</li>
+     * </ol>
+     * The primary omissions are tooltips and clickable actions. Consequently, this method should be used only as a last resort.
+     * <p>
+     * Color and formatting can be removed from the returned string by using {@link ChatColor#stripColor(String)}.</p>
+     *
+     * @return A human-readable string representing limited formatting in addition to the core text of this message.
+     */
+    public String toOldMessageFormat() {
+        StringBuilder result = new StringBuilder();
+        for (MessagePart part : this) {
+            result.append(part.color == null ? "" : part.color);
+            for (ChatColor formatSpecifier : part.styles) {
+                result.append(formatSpecifier);
+            }
+            result.append(part.text);
+        }
+        return result.toString();
+    }
+
+    private MessagePart latest() {
+        return messageParts.get(messageParts.size() - 1);
+    }
+
+    private void onClick(final String name, final String data) {
+        final MessagePart latest = latest();
+        latest.clickActionName = name;
+        latest.clickActionData = data;
+        dirty = true;
+    }
+
+    private void onHover(final String name, final JsonRepresentedObject data) {
+        final MessagePart latest = latest();
+        latest.hoverActionName = name;
+        latest.hoverActionData = data;
+        dirty = true;
+    }
+
+    // Doc copied from interface
+    public Map<String, Object> serialize() {
+        HashMap<String, Object> map = new HashMap<>();
+        map.put("messageParts", messageParts);
+        //		map.put("JSON", toJSONString());
+        return map;
+    }
+
+    /**
+     * <b>Internally called method. Not for API consumption.</b>
+     */
+    public Iterator<MessagePart> iterator() {
+        return messageParts.iterator();
+    }
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/chat/JsonRepresentedObject.java

@@ -0,0 +1,20 @@
+package com.github.intellectualsites.plotsquared.bukkit.chat;
+
+import com.google.gson.stream.JsonWriter;
+
+import java.io.IOException;
+
+/**
+ * Represents an object that can be serialized to a JSON writer instance.
+ */
+interface JsonRepresentedObject {
+
+    /**
+     * Writes the JSON representation of this object to the specified writer.
+     *
+     * @param writer The JSON writer which will receive the object.
+     * @throws IOException If an error occurs writing to the stream.
+     */
+    public void writeJson(JsonWriter writer) throws IOException;
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/chat/JsonString.java

@@ -0,0 +1,45 @@
+package com.github.intellectualsites.plotsquared.bukkit.chat;
+
+import com.google.gson.stream.JsonWriter;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Represents a JSON string value.
+ * Writes by this object will not write name values nor begin/end objects in the JSON stream.
+ * All writes merely write the represented string value.
+ */
+final class JsonString implements JsonRepresentedObject, ConfigurationSerializable {
+
+    private String _value;
+
+    public JsonString(CharSequence value) {
+        _value = value == null ? null : value.toString();
+    }
+
+    public static JsonString deserialize(Map<String, Object> map) {
+        return new JsonString(map.get("stringValue").toString());
+    }
+
+    @Override public void writeJson(JsonWriter writer) throws IOException {
+        writer.value(getValue());
+    }
+
+    public String getValue() {
+        return _value;
+    }
+
+    public Map<String, Object> serialize() {
+        HashMap<String, Object> theSingleValue = new HashMap<String, Object>();
+        theSingleValue.put("stringValue", _value);
+        return theSingleValue;
+    }
+
+    @Override public String toString() {
+        return _value;
+    }
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/chat/MessagePart.java

@@ -0,0 +1,154 @@
+package com.github.intellectualsites.plotsquared.bukkit.chat;
+
+import com.google.common.collect.BiMap;
+import com.google.common.collect.ImmutableBiMap;
+import com.google.gson.stream.JsonWriter;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Level;
+
+/**
+ * Internal class: Represents a component of a JSON-serializable {@link FancyMessage}.
+ */
+final class MessagePart implements JsonRepresentedObject, ConfigurationSerializable, Cloneable {
+
+    static final BiMap<ChatColor, String> stylesToNames;
+
+    static {
+        ImmutableBiMap.Builder<ChatColor, String> builder = ImmutableBiMap.builder();
+        for (final ChatColor style : ChatColor.values()) {
+            if (!style.isFormat()) {
+                continue;
+            }
+
+            String styleName;
+            switch (style) {
+                case MAGIC:
+                    styleName = "obfuscated";
+                    break;
+                case UNDERLINE:
+                    styleName = "underlined";
+                    break;
+                default:
+                    styleName = style.name().toLowerCase();
+                    break;
+            }
+
+            builder.put(style, styleName);
+        }
+        stylesToNames = builder.build();
+    }
+
+    static {
+        ConfigurationSerialization.registerClass(MessagePart.class);
+    }
+
+    ChatColor color = ChatColor.WHITE;
+    ArrayList<ChatColor> styles = new ArrayList<>();
+    String clickActionName = null;
+    String clickActionData = null;
+    String hoverActionName = null;
+    JsonRepresentedObject hoverActionData = null;
+    TextualComponent text = null;
+    String insertionData = null;
+    ArrayList<JsonRepresentedObject> translationReplacements = new ArrayList<>();
+
+    MessagePart(final TextualComponent text) {
+        this.text = text;
+    }
+
+    MessagePart() {
+        this.text = null;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static MessagePart deserialize(Map<String, Object> serialized) {
+        MessagePart part = new MessagePart((TextualComponent) serialized.get("text"));
+        part.styles = (ArrayList<ChatColor>) serialized.get("styles");
+        part.color = ChatColor.getByChar(serialized.get("color").toString());
+        part.hoverActionName = (String) serialized.get("hoverActionName");
+        part.hoverActionData = (JsonRepresentedObject) serialized.get("hoverActionData");
+        part.clickActionName = (String) serialized.get("clickActionName");
+        part.clickActionData = (String) serialized.get("clickActionData");
+        part.insertionData = (String) serialized.get("insertion");
+        part.translationReplacements =
+            (ArrayList<JsonRepresentedObject>) serialized.get("translationReplacements");
+        return part;
+    }
+
+    boolean hasText() {
+        return text != null;
+    }
+
+    @Override @SuppressWarnings("unchecked") public MessagePart clone()
+        throws CloneNotSupportedException {
+        MessagePart obj = (MessagePart) super.clone();
+        obj.styles = (ArrayList<ChatColor>) styles.clone();
+        if (hoverActionData instanceof JsonString) {
+            obj.hoverActionData = new JsonString(((JsonString) hoverActionData).getValue());
+        } else if (hoverActionData instanceof FancyMessage) {
+            obj.hoverActionData = ((FancyMessage) hoverActionData).clone();
+        }
+        obj.translationReplacements =
+            (ArrayList<JsonRepresentedObject>) translationReplacements.clone();
+        return obj;
+
+    }
+
+    public void writeJson(JsonWriter json) {
+        try {
+            json.beginObject();
+            text.writeJson(json);
+            json.name("color").value(color.name().toLowerCase());
+            for (final ChatColor style : styles) {
+                json.name(stylesToNames.get(style)).value(true);
+            }
+            if (clickActionName != null && clickActionData != null) {
+                json.name("clickEvent").beginObject().name("action").value(clickActionName)
+                    .name("value").value(clickActionData).endObject();
+            }
+            if (hoverActionName != null && hoverActionData != null) {
+                json.name("hoverEvent").beginObject().name("action").value(hoverActionName)
+                    .name("value");
+                hoverActionData.writeJson(json);
+                json.endObject();
+            }
+            if (insertionData != null) {
+                json.name("insertion").value(insertionData);
+            }
+            if (translationReplacements.size() > 0 && TextualComponent.isTranslatableText(text)) {
+                json.name("with").beginArray();
+                for (JsonRepresentedObject obj : translationReplacements) {
+                    obj.writeJson(json);
+                }
+                json.endArray();
+            }
+            json.endObject();
+        } catch (IOException e) {
+            Bukkit.getLogger()
+                .log(Level.WARNING, "A problem occurred during writing of JSON string", e);
+        }
+    }
+
+    public Map<String, Object> serialize() {
+        HashMap<String, Object> map = new HashMap<>();
+        map.put("text", text);
+        map.put("styles", styles);
+        map.put("color", color.getChar());
+        map.put("hoverActionName", hoverActionName);
+        map.put("hoverActionData", hoverActionData);
+        map.put("clickActionName", clickActionName);
+        map.put("clickActionData", clickActionData);
+        map.put("insertion", insertionData);
+        map.put("translationReplacements", translationReplacements);
+        return map;
+    }
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/chat/Reflection.java

@@ -0,0 +1,202 @@
+package com.github.intellectualsites.plotsquared.bukkit.chat;
+
+import org.bukkit.Bukkit;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A class containing static utility methods and caches which are intended as reflective conveniences.
+ * Unless otherwise noted, upon failure methods will return {@code null}.
+ */
+public final class Reflection {
+
+    /**
+     * Stores loaded classes from the {@code net.minecraft.server} package.
+     */
+    private static final Map<String, Class<?>> _loadedNMSClasses = new HashMap<>();
+    /**
+     * Stores loaded classes from the {@code org.bukkit.craftbukkit} package (and subpackages).
+     */
+    private static final Map<String, Class<?>> _loadedOBCClasses = new HashMap<>();
+    private static final Map<Class<?>, Map<String, Field>> _loadedFields = new HashMap<>();
+    /**
+     * Contains loaded methods in a cache.
+     * The map maps [types to maps of [method names to maps of [parameter types to method instances]]].
+     */
+    private static final Map<Class<?>, Map<String, Map<ArrayWrapper<Class<?>>, Method>>>
+        _loadedMethods = new HashMap<>();
+    private static String _versionString;
+
+    private Reflection() {
+    }
+
+    /**
+     * Gets the version string from the package name of the CraftBukkit server implementation.
+     * This is needed to bypass the JAR package name changing on each update.
+     *
+     * @return The version string of the OBC and NMS packages, <em>including the trailing dot</em>.
+     */
+    public synchronized static String getVersion() {
+        if (_versionString == null) {
+            String name = Bukkit.getServer().getClass().getPackage().getName();
+            _versionString = name.substring(name.lastIndexOf('.') + 1) + ".";
+        }
+
+        return _versionString;
+    }
+
+    /**
+     * Gets a {@link Class} object representing a type contained within the {@code net.minecraft.server} versioned package.
+     * The class instances returned by this method are cached, such that no lookup will be done twice (unless multiple threads are accessing this method simultaneously).
+     *
+     * @param className The name of the class, excluding the package, within NMS.
+     * @return The class instance representing the specified NMS class, or {@code null} if it could not be loaded.
+     */
+    public synchronized static Class<?> getNMSClass(String className) {
+        if (_loadedNMSClasses.containsKey(className)) {
+            return _loadedNMSClasses.get(className);
+        }
+
+        String fullName = "net.minecraft.server." + getVersion() + className;
+        Class<?> clazz;
+        try {
+            clazz = Class.forName(fullName);
+        } catch (ClassNotFoundException e) {
+            _loadedNMSClasses.put(className, null);
+            throw new RuntimeException(e);
+        }
+        _loadedNMSClasses.put(className, clazz);
+        return clazz;
+    }
+
+    /**
+     * Gets a {@link Class} object representing a type contained within the {@code org.bukkit.craftbukkit} versioned package.
+     * The class instances returned by this method are cached, such that no lookup will be done twice (unless multiple threads are accessing this method simultaneously).
+     *
+     * @param className The name of the class, excluding the package, within OBC. This name may contain a subpackage name, such as {@code inventory.CraftItemStack}.
+     * @return The class instance representing the specified OBC class, or {@code null} if it could not be loaded.
+     */
+    public synchronized static Class<?> getOBCClass(String className) {
+        if (_loadedOBCClasses.containsKey(className)) {
+            return _loadedOBCClasses.get(className);
+        }
+
+        String fullName = "org.bukkit.craftbukkit." + getVersion() + className;
+        Class<?> clazz;
+        try {
+            clazz = Class.forName(fullName);
+        } catch (ClassNotFoundException e) {
+            _loadedOBCClasses.put(className, null);
+            throw new RuntimeException(e);
+        }
+        _loadedOBCClasses.put(className, clazz);
+        return clazz;
+    }
+
+    /**
+     * Attempts to get the NMS handle of a CraftBukkit object.
+     * <p>
+     * The only match currently attempted by this method is a retrieval by using a parameterless {@code getHandle()} method implemented by the runtime type of the specified object.
+     * </p>
+     *
+     * @param obj The object for which to retrieve an NMS handle.
+     * @return The NMS handle of the specified object, or {@code null} if it could not be retrieved using {@code getHandle()}.
+     */
+    public synchronized static Object getHandle(Object obj)
+        throws InvocationTargetException, IllegalAccessException, IllegalArgumentException {
+        return getMethod(obj.getClass(), "getHandle").invoke(obj);
+    }
+
+    /**
+     * Retrieves a {@link Field} instance declared by the specified class with the specified name.
+     * Java access modifiers are ignored during this retrieval. No guarantee is made as to whether the field
+     * returned will be an instance or static field.
+     * <p>
+     * A global caching mechanism within this class is used to store fields. Combined with synchronization, this guarantees that
+     * no field will be reflectively looked up twice.
+     * </p>
+     * <p>
+     * If a field is deemed suitable for return, {@link Field#setAccessible(boolean) setAccessible} will be invoked with an argument of {@code true} before it is returned.
+     * This ensures that callers do not have to check or worry about Java access modifiers when dealing with the returned instance.
+     * </p>
+     *
+     * @param clazz The class which contains the field to retrieve.
+     * @param name  The declared name of the field in the class.
+     * @return A field object with the specified name declared by the specified class.
+     * @see Class#getDeclaredField(String)
+     */
+    public synchronized static Field getField(Class<?> clazz, String name) {
+        Map<String, Field> loaded;
+        if (!_loadedFields.containsKey(clazz)) {
+            loaded = new HashMap<>();
+            _loadedFields.put(clazz, loaded);
+        } else {
+            loaded = _loadedFields.get(clazz);
+        }
+        if (loaded.containsKey(name)) {
+            // If the field is loaded (or cached as not existing), return the relevant value, which might be null
+            return loaded.get(name);
+        }
+        try {
+            Field field = clazz.getDeclaredField(name);
+            field.setAccessible(true);
+            loaded.put(name, field);
+            return field;
+        } catch (NoSuchFieldException | SecurityException e) {
+            // Error loading
+            e.printStackTrace();
+            // Cache field as not existing
+            loaded.put(name, null);
+            return null;
+        }
+    }
+
+    /**
+     * Retrieves a {@link Method} instance declared by the specified class with the specified name and argument types.
+     * Java access modifiers are ignored during this retrieval. No guarantee is made as to whether the field
+     * returned will be an instance or static field.
+     * <p>
+     * A global caching mechanism within this class is used to store method. Combined with synchronization, this guarantees that
+     * no method will be reflectively looked up twice.
+     * <p>
+     * If a method is deemed suitable for return, {@link Method#setAccessible(boolean) setAccessible} will be invoked with an argument of {@code true} before it is returned.
+     * This ensures that callers do not have to check or worry about Java access modifiers when dealing with the returned instance.
+     * <p>
+     * This method does <em>not</em> search superclasses of the specified type for methods with the specified signature.
+     * Callers wishing this behavior should use {@link Class#getDeclaredMethod(String, Class...)}.
+     *
+     * @param clazz The class which contains the method to retrieve.
+     * @param name  The declared name of the method in the class.
+     * @param args  The formal argument types of the method.
+     * @return A method object with the specified name declared by the specified class.
+     */
+    public synchronized static Method getMethod(Class<?> clazz, String name, Class<?>... args) {
+        _loadedMethods.computeIfAbsent(clazz, k -> new HashMap<>());
+
+        Map<String, Map<ArrayWrapper<Class<?>>, Method>> loadedMethodNames =
+            _loadedMethods.get(clazz);
+        loadedMethodNames.computeIfAbsent(name, k -> new HashMap<>());
+
+        Map<ArrayWrapper<Class<?>>, Method> loadedSignatures = loadedMethodNames.get(name);
+        ArrayWrapper<Class<?>> wrappedArg = new ArrayWrapper<>(args);
+        if (loadedSignatures.containsKey(wrappedArg)) {
+            return loadedSignatures.get(wrappedArg);
+        }
+
+        for (Method m : clazz.getMethods()) {
+            if (m.getName().equals(name) && Arrays.equals(args, m.getParameterTypes())) {
+                m.setAccessible(true);
+                loadedSignatures.put(wrappedArg, m);
+                return m;
+            }
+        }
+        loadedSignatures.put(wrappedArg, null);
+        return null;
+    }
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/chat/TextualComponent.java

@@ -0,0 +1,313 @@
+package com.github.intellectualsites.plotsquared.bukkit.chat;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableMap;
+import com.google.gson.stream.JsonWriter;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Represents a textual component of a message part.
+ * This can be used to not only represent string literals in a JSON message,
+ * but also to represent localized strings and other text values.
+ * <p>Different instances of this class can be created with static constructor methods.</p>
+ */
+public abstract class TextualComponent implements Cloneable {
+
+    static {
+        ConfigurationSerialization.registerClass(TextualComponent.ArbitraryTextTypeComponent.class);
+        ConfigurationSerialization.registerClass(TextualComponent.ComplexTextTypeComponent.class);
+    }
+
+    static TextualComponent deserialize(Map<String, Object> map) {
+        if (map.containsKey("key") && map.size() == 2 && map.containsKey("value")) {
+            // Arbitrary text component
+            return ArbitraryTextTypeComponent.deserialize(map);
+        } else if (map.size() >= 2 && map.containsKey("key") && !map
+            .containsKey("value") /* It contains keys that START WITH value */) {
+            // Complex JSON object
+            return ComplexTextTypeComponent.deserialize(map);
+        }
+
+        return null;
+    }
+
+    static boolean isTextKey(String key) {
+        return key.equals("translate") || key.equals("text") || key.equals("score") || key
+            .equals("selector");
+    }
+
+    static boolean isTranslatableText(TextualComponent component) {
+        return component instanceof ComplexTextTypeComponent && component.getKey()
+            .equals("translate");
+    }
+
+    /**
+     * Create a textual component representing a string literal.
+     *
+     * <p>This is the default type of textual component when a single string
+     * literal is given to a method.
+     *
+     * @param textValue The text which will be represented.
+     * @return The text component representing the specified literal text.
+     */
+    public static TextualComponent rawText(String textValue) {
+        return new ArbitraryTextTypeComponent("text", textValue);
+    }
+
+    /**
+     * Create a textual component representing a localized string.
+     * The client will see this text component as their localized version of the specified string <em>key</em>, which can be overridden by a
+     * resource pack.
+     * <p>
+     * If the specified translation key is not present on the client resource pack, the translation key will be displayed as a string literal to
+     * the client.
+     * </p>
+     *
+     * @param translateKey The string key which maps to localized text.
+     * @return The text component representing the specified localized text.
+     */
+    public static TextualComponent localizedText(String translateKey) {
+        return new ArbitraryTextTypeComponent("translate", translateKey);
+    }
+
+    private static void throwUnsupportedSnapshot() {
+        throw new UnsupportedOperationException(
+            "This feature is only supported in snapshot releases.");
+    }
+
+    /**
+     * Create a textual component representing a scoreboard value.
+     * The client will see their own score for the specified objective as the text represented by this component.
+     * <p>
+     * <b>This method is currently guaranteed to throw an {@code UnsupportedOperationException} as it is only supported on snapshot clients.</b>
+     * </p>
+     *
+     * @param scoreboardObjective The name of the objective for which to display the score.
+     * @return The text component representing the specified scoreboard score (for the viewing player), or {@code null} if an error occurs during
+     * JSON serialization.
+     */
+    public static TextualComponent objectiveScore(String scoreboardObjective) {
+        return objectiveScore("*", scoreboardObjective);
+    }
+
+    /**
+     * Create a textual component representing a scoreboard value.
+     * The client will see the score of the specified player for the specified objective as the text represented by this component.
+     *
+     * <p><b>This method is currently guaranteed to throw an {@code UnsupportedOperationException}
+     * as it is only supported on snapshot clients.</b>
+     *
+     * @param playerName          The name of the player whos score will be shown. If
+     *                            this string represents the single-character sequence
+     *                            "*", the viewing player's score will be displayed.
+     *                            Standard minecraft selectors (@a, @p, etc)
+     *                            are <em>not</em> supported.
+     * @param scoreboardObjective The name of the objective for
+     *                            which to display the score.
+     * @return The text component representing the specified scoreboard score
+     * for the specified player, or {@code null} if an error occurs during JSON serialization.
+     */
+    public static TextualComponent objectiveScore(String playerName, String scoreboardObjective) {
+        throwUnsupportedSnapshot(); // Remove this line when the feature is released to non-snapshot versions, in addition to updating ALL THE
+        // OVERLOADS documentation accordingly
+
+        return new ComplexTextTypeComponent("score",
+            ImmutableMap.<String, String>builder().put("name", playerName)
+                .put("objective", scoreboardObjective).build());
+    }
+
+    /**
+     * Create a textual component representing a player name, retrievable by using a standard minecraft selector.
+     * The client will see the players or entities captured by the specified selector as the text represented by this component.
+     * <p>
+     * <b>This method is currently guaranteed to throw an {@code UnsupportedOperationException} as it is only supported on snapshot clients.</b>
+     * </p>
+     *
+     * @param selector The minecraft player or entity selector which will capture the entities whose string representations will be displayed in
+     *                 the place of this text component.
+     * @return The text component representing the name of the entities captured by the selector.
+     */
+    public static TextualComponent selector(String selector) {
+        throwUnsupportedSnapshot(); // Remove this line when the feature is released to non-snapshot versions, in addition to updating ALL THE
+        // OVERLOADS documentation accordingly
+
+        return new ArbitraryTextTypeComponent("selector", selector);
+    }
+
+    @Override public String toString() {
+        return getReadableString();
+    }
+
+    /**
+     * @return The JSON key used to represent text components of this type.
+     */
+    public abstract String getKey();
+
+    /**
+     * @return A readable String
+     */
+    public abstract String getReadableString();
+
+    /**
+     * Clones a textual component instance.
+     * The returned object should not reference this textual component instance, but should maintain the same key and value.
+     */
+    @Override public abstract TextualComponent clone() throws CloneNotSupportedException;
+
+    /**
+     * Writes the text data represented by this textual component to the specified JSON writer object.
+     * A new object within the writer is not started.
+     *
+     * @param writer The object to which to write the JSON data.
+     * @throws IOException If an error occurs while writing to the stream.
+     */
+    public abstract void writeJson(JsonWriter writer) throws IOException;
+
+    /**
+     * Internal class used to represent all types of text components.
+     * Exception validating done is on keys and values.
+     */
+    private static final class ArbitraryTextTypeComponent extends TextualComponent
+        implements ConfigurationSerializable {
+
+        private String key;
+        private String value;
+
+        public ArbitraryTextTypeComponent(String key, String value) {
+            setKey(key);
+            setValue(value);
+        }
+
+        public static ArbitraryTextTypeComponent deserialize(Map<String, Object> map) {
+            return new ArbitraryTextTypeComponent(map.get("key").toString(),
+                map.get("value").toString());
+        }
+
+        @Override public String getKey() {
+            return key;
+        }
+
+        public void setKey(String key) {
+            Preconditions
+                .checkArgument(key != null && !key.isEmpty(), "The key must be specified.");
+            this.key = key;
+        }
+
+        public String getValue() {
+            return value;
+        }
+
+        public void setValue(String value) {
+            Preconditions.checkArgument(value != null, "The value must be specified.");
+            this.value = value;
+        }
+
+        @Override public TextualComponent clone() throws CloneNotSupportedException {
+            // Since this is a private and final class, we can just reinstantiate this class instead of casting super.clone
+            return new ArbitraryTextTypeComponent(getKey(), getValue());
+        }
+
+        @Override public void writeJson(JsonWriter writer) throws IOException {
+            writer.name(getKey()).value(getValue());
+        }
+
+        @Override @SuppressWarnings("serial") public Map<String, Object> serialize() {
+            return new HashMap<String, Object>() {
+                {
+                    put("key", getKey());
+                    put("value", getValue());
+                }
+            };
+        }
+
+        @Override public String getReadableString() {
+            return getValue();
+        }
+    }
+
+
+    /**
+     * Internal class used to represent a text component with a nested JSON
+     * value.
+     *
+     * <p>Exception validating done is on keys and values.
+     */
+    private static final class ComplexTextTypeComponent extends TextualComponent
+        implements ConfigurationSerializable {
+
+        private String key;
+        private Map<String, String> value;
+
+        public ComplexTextTypeComponent(String key, Map<String, String> values) {
+            setKey(key);
+            setValue(values);
+        }
+
+        public static ComplexTextTypeComponent deserialize(Map<String, Object> map) {
+            String key = null;
+            Map<String, String> value = new HashMap<>();
+            for (Map.Entry<String, Object> valEntry : map.entrySet()) {
+                if (valEntry.getKey().equals("key")) {
+                    key = (String) valEntry.getValue();
+                } else if (valEntry.getKey().startsWith("value.")) {
+                    value.put(valEntry.getKey().substring(6) /* Strips out the value prefix */,
+                        valEntry.getValue().toString());
+                }
+            }
+            return new ComplexTextTypeComponent(key, value);
+        }
+
+        @Override public String getKey() {
+            return key;
+        }
+
+        public void setKey(String key) {
+            Preconditions
+                .checkArgument(key != null && !key.isEmpty(), "The key must be specified.");
+            this.key = key;
+        }
+
+        public Map<String, String> getValue() {
+            return value;
+        }
+
+        public void setValue(Map<String, String> value) {
+            Preconditions.checkArgument(value != null, "The value must be specified.");
+            this.value = value;
+        }
+
+        @Override public TextualComponent clone() {
+            // Since this is a private and final class, we can just reinstantiate this class instead of casting super.clone
+            return new ComplexTextTypeComponent(getKey(), getValue());
+        }
+
+        @Override public void writeJson(JsonWriter writer) throws IOException {
+            writer.name(getKey());
+            writer.beginObject();
+            for (Map.Entry<String, String> jsonPair : value.entrySet()) {
+                writer.name(jsonPair.getKey()).value(jsonPair.getValue());
+            }
+            writer.endObject();
+        }
+
+        @Override @SuppressWarnings("serial") public Map<String, Object> serialize() {
+            return new java.util.HashMap<String, Object>() {
+                {
+                    put("key", getKey());
+                    for (Map.Entry<String, String> valEntry : getValue().entrySet()) {
+                        put("value." + valEntry.getKey(), valEntry.getValue());
+                    }
+                }
+            };
+        }
+
+        @Override public String getReadableString() {
+            return getKey();
+        }
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/commands/DebugUUID.java

@@ -0,0 +1,295 @@
+package com.github.intellectualsites.plotsquared.bukkit.commands;
+
+import com.github.intellectualsites.plotsquared.bukkit.uuid.DatFileFilter;
+import com.github.intellectualsites.plotsquared.bukkit.uuid.DefaultUUIDWrapper;
+import com.github.intellectualsites.plotsquared.bukkit.uuid.LowerOfflineUUIDWrapper;
+import com.github.intellectualsites.plotsquared.bukkit.uuid.OfflineUUIDWrapper;
+import com.github.intellectualsites.plotsquared.commands.Argument;
+import com.github.intellectualsites.plotsquared.commands.CommandDeclaration;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.commands.CommandCategory;
+import com.github.intellectualsites.plotsquared.plot.commands.RequiredType;
+import com.github.intellectualsites.plotsquared.plot.commands.SubCommand;
+import com.github.intellectualsites.plotsquared.plot.config.Captions;
+import com.github.intellectualsites.plotsquared.plot.database.DBFunc;
+import com.github.intellectualsites.plotsquared.plot.object.OfflinePlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.StringWrapper;
+import com.github.intellectualsites.plotsquared.plot.util.MainUtil;
+import com.github.intellectualsites.plotsquared.plot.util.StringMan;
+import com.github.intellectualsites.plotsquared.plot.util.TaskManager;
+import com.github.intellectualsites.plotsquared.plot.util.UUIDHandler;
+import com.github.intellectualsites.plotsquared.plot.util.WorldUtil;
+import com.github.intellectualsites.plotsquared.plot.uuid.UUIDWrapper;
+import com.google.common.collect.Sets;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.UUID;
+
+@CommandDeclaration(command = "uuidconvert", permission = "plots.admin",
+    description = "Debug UUID conversion", usage = "/plot uuidconvert <lower|offline|online>",
+    requiredType = RequiredType.CONSOLE, category = CommandCategory.DEBUG) public class DebugUUID
+    extends SubCommand {
+
+    public DebugUUID() {
+        super(Argument.String);
+    }
+
+    @Override public boolean onCommand(final PlotPlayer player, String[] args) {
+        final UUIDWrapper currentUUIDWrapper = UUIDHandler.getUUIDWrapper();
+        final UUIDWrapper newWrapper;
+
+        switch (args[0].toLowerCase()) {
+            case "lower":
+                newWrapper = new LowerOfflineUUIDWrapper();
+                break;
+            case "offline":
+                newWrapper = new OfflineUUIDWrapper();
+                break;
+            case "online":
+                newWrapper = new DefaultUUIDWrapper();
+                break;
+            default:
+                try {
+                    Class<?> clazz = Class.forName(args[0]);
+                    newWrapper = (UUIDWrapper) clazz.newInstance();
+                } catch (ClassNotFoundException | IllegalAccessException | InstantiationException ignored) {
+                    MainUtil.sendMessage(player, Captions.COMMAND_SYNTAX,
+                        "/plot uuidconvert <lower|offline|online>");
+                    return false;
+                }
+        }
+
+        if (args.length != 2 || !"-o".equals(args[1])) {
+            MainUtil.sendMessage(player, Captions.COMMAND_SYNTAX,
+                "/plot uuidconvert " + args[0] + " -o");
+            MainUtil.sendMessage(player, "&cBe aware of the following!");
+            MainUtil.sendMessage(player,
+                "&8 - &cUse the database command or another method to backup your plots beforehand");
+            MainUtil.sendMessage(player,
+                "&8 - &cIf the process is interrupted, all plots could be deleted");
+            MainUtil.sendMessage(player, "&8 - &cIf an error occurs, all plots could be deleted");
+            MainUtil.sendMessage(player, "&8 - &cPlot settings WILL be lost upon conversion");
+            MainUtil
+                .sendMessage(player, "&cTO REITERATE: BACK UP YOUR DATABASE BEFORE USING THIS!!!");
+            MainUtil.sendMessage(player,
+                "&7Retype the command with the override parameter when ready :)");
+            return false;
+        }
+
+        if (currentUUIDWrapper.getClass().getCanonicalName()
+            .equals(newWrapper.getClass().getCanonicalName())) {
+            MainUtil.sendMessage(player, "&cUUID mode already in use!");
+            return false;
+        }
+        MainUtil.sendMessage(player, "&6Beginning UUID mode conversion");
+        MainUtil.sendMessage(player, "&7 - Disconnecting players");
+        for (Entry<String, PlotPlayer> entry : UUIDHandler.getPlayers().entrySet()) {
+            entry.getValue()
+                .kick("UUID conversion has been initiated. You may reconnect when finished.");
+        }
+
+        MainUtil.sendMessage(player, "&7 - Initializing map");
+
+        final HashMap<UUID, UUID> uCMap = new HashMap<>();
+        final HashMap<UUID, UUID> uCReverse = new HashMap<>();
+
+        MainUtil.sendMessage(player, "&7 - Collecting playerdata");
+
+        HashSet<String> worlds = Sets.newHashSet(WorldUtil.IMP.getMainWorld(), "world");
+        HashSet<UUID> uuids = new HashSet<>();
+        HashSet<String> names = new HashSet<>();
+        for (String worldName : worlds) {
+            File playerDataFolder = new File(worldName + File.separator + "playerdata");
+            String[] dat = playerDataFolder.list(new DatFileFilter());
+            if (dat != null) {
+                for (String current : dat) {
+                    String s = current.replaceAll(".dat$", "");
+                    try {
+                        UUID uuid = UUID.fromString(s);
+                        uuids.add(uuid);
+                    } catch (Exception ignored) {
+                        MainUtil.sendMessage(player,
+                            Captions.PREFIX + "Invalid playerdata: " + current);
+                    }
+                }
+            }
+            File playersFolder = new File(worldName + File.separator + "players");
+            dat = playersFolder.list(new DatFileFilter());
+            if (dat != null) {
+                for (String current : dat) {
+                    names.add(current.replaceAll(".dat$", ""));
+                }
+            }
+        }
+
+        MainUtil.sendMessage(player, "&7 - Populating map");
+        UUID uuid2;
+        UUIDWrapper wrapper = new DefaultUUIDWrapper();
+        for (UUID uuid : uuids) {
+            try {
+                OfflinePlotPlayer op = wrapper.getOfflinePlayer(uuid);
+                uuid = currentUUIDWrapper.getUUID(op);
+                uuid2 = newWrapper.getUUID(op);
+                if (!uuid.equals(uuid2) && !uCMap.containsKey(uuid) && !uCReverse
+                    .containsKey(uuid2)) {
+                    uCMap.put(uuid, uuid2);
+                    uCReverse.put(uuid2, uuid);
+                }
+            } catch (Throwable ignored) {
+                MainUtil.sendMessage(player,
+                    Captions.PREFIX + "&6Invalid playerdata: " + uuid.toString() + ".dat");
+            }
+        }
+        for (String name : names) {
+            UUID uuid = currentUUIDWrapper.getUUID(name);
+            uuid2 = newWrapper.getUUID(name);
+            if (!uuid.equals(uuid2)) {
+                uCMap.put(uuid, uuid2);
+                uCReverse.put(uuid2, uuid);
+            }
+        }
+        if (uCMap.isEmpty()) {
+            MainUtil.sendMessage(player, "&c - Error! Attempting to repopulate");
+            for (OfflinePlotPlayer op : currentUUIDWrapper.getOfflinePlayers()) {
+                if (op.getLastPlayed() != 0) {
+                    //                    String name = op.getPluginName();
+                    //                    StringWrapper wrap = new StringWrapper(name);
+                    UUID uuid = currentUUIDWrapper.getUUID(op);
+                    uuid2 = newWrapper.getUUID(op);
+                    if (!uuid.equals(uuid2)) {
+                        uCMap.put(uuid, uuid2);
+                        uCReverse.put(uuid2, uuid);
+                    }
+                }
+            }
+            if (uCMap.isEmpty()) {
+                MainUtil.sendMessage(player, "&cError. Failed to collect UUIDs!");
+                return false;
+            } else {
+                MainUtil.sendMessage(player, "&a - Successfully repopulated");
+            }
+        }
+
+        MainUtil.sendMessage(player, "&7 - Replacing cache");
+        TaskManager.runTaskAsync(() -> {
+            for (Entry<UUID, UUID> entry : uCMap.entrySet()) {
+                String name = UUIDHandler.getName(entry.getKey());
+                if (name != null) {
+                    UUIDHandler.add(new StringWrapper(name), entry.getValue());
+                }
+            }
+
+            MainUtil.sendMessage(player, "&7 - Scanning for applicable files (uuids.txt)");
+
+            File file = new File(PlotSquared.get().IMP.getDirectory(), "uuids.txt");
+            if (file.exists()) {
+                try {
+                    List<String> lines = Files.readAllLines(file.toPath(), StandardCharsets.UTF_8);
+                    for (String line : lines) {
+                        try {
+                            line = line.trim();
+                            if (line.isEmpty()) {
+                                continue;
+                            }
+                            line = line.replaceAll("[\\|][0-9]+[\\|][0-9]+[\\|]", "");
+                            String[] split = line.split("\\|");
+                            String name = split[0];
+                            if (name.isEmpty() || name.length() > 16 || !StringMan
+                                .isAlphanumericUnd(name)) {
+                                continue;
+                            }
+                            UUID old = currentUUIDWrapper.getUUID(name);
+                            if (old == null) {
+                                continue;
+                            }
+                            UUID now = newWrapper.getUUID(name);
+                            UUIDHandler.add(new StringWrapper(name), now);
+                            uCMap.put(old, now);
+                            uCReverse.put(now, old);
+                        } catch (Exception e2) {
+                            e2.printStackTrace();
+                        }
+                    }
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+
+            MainUtil.sendMessage(player, "&7 - Replacing wrapper");
+            UUIDHandler.setUUIDWrapper(newWrapper);
+
+            MainUtil.sendMessage(player, "&7 - Updating plot objects");
+
+            for (Plot plot : PlotSquared.get().getPlots()) {
+                UUID value = uCMap.get(plot.owner);
+                if (value != null) {
+                    plot.owner = value;
+                }
+                plot.getTrusted().clear();
+                plot.getMembers().clear();
+                plot.getDenied().clear();
+            }
+
+            MainUtil.sendMessage(player, "&7 - Deleting database");
+            boolean result = DBFunc.deleteTables();
+
+            MainUtil.sendMessage(player, "&7 - Creating tables");
+
+            try {
+                DBFunc.createTables();
+                if (!result) {
+                    MainUtil.sendMessage(player, "&cConversion failed! Attempting recovery");
+                    for (Plot plot : PlotSquared.get().getPlots()) {
+                        UUID value = uCReverse.get(plot.owner);
+                        if (value != null) {
+                            plot.owner = value;
+                        }
+                    }
+                    DBFunc.createPlotsAndData(new ArrayList<>(PlotSquared.get().getPlots()),
+                        () -> MainUtil.sendMessage(player, "&6Recovery was successful!"));
+                    return;
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+                return;
+            }
+
+            if (newWrapper instanceof OfflineUUIDWrapper) {
+                PlotSquared.get().worlds.set("UUID.force-lowercase", false);
+                PlotSquared.get().worlds.set("UUID.offline", true);
+            } else if (newWrapper instanceof DefaultUUIDWrapper) {
+                PlotSquared.get().worlds.set("UUID.force-lowercase", false);
+                PlotSquared.get().worlds.set("UUID.offline", false);
+            }
+            try {
+                PlotSquared.get().worlds.save(PlotSquared.get().worldsFile);
+            } catch (IOException ignored) {
+                MainUtil.sendMessage(player,
+                    "Could not save configuration. It will need to be manual set!");
+            }
+
+            MainUtil.sendMessage(player, "&7 - Populating tables");
+
+            TaskManager.runTaskAsync(() -> {
+                ArrayList<Plot> plots = new ArrayList<>(PlotSquared.get().getPlots());
+                DBFunc.createPlotsAndData(plots,
+                    () -> MainUtil.sendMessage(player, "&aConversion complete!"));
+            });
+
+            MainUtil.sendMessage(player, "&aIt is now safe for players to join");
+            MainUtil.sendMessage(player,
+                "&cConversion is still in progress, you will be notified when it is complete");
+        });
+        return true;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlayerClaimPlotEvent.java

@@ -0,0 +1,59 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.player.PlayerEvent;
+
+public class PlayerClaimPlotEvent extends PlayerEvent implements Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final Plot plot;
+    private final boolean auto;
+    private boolean cancelled;
+
+    /**
+     * PlayerClaimPlotEvent: Called when a plot is claimed.
+     *
+     * @param player Player that claimed the plot
+     * @param plot   Plot that was claimed
+     */
+    public PlayerClaimPlotEvent(Player player, Plot plot, boolean auto) {
+        super(player);
+        this.plot = plot;
+        this.auto = auto;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Get the plot involved
+     *
+     * @return Plot
+     */
+    public Plot getPlot() {
+        return this.plot;
+    }
+
+    /**
+     * @return true if it was an automated claim, else false
+     */
+    public boolean wasAuto() {
+        return this.auto;
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    @Override public boolean isCancelled() {
+        return this.cancelled;
+    }
+
+    @Override public void setCancelled(boolean b) {
+        this.cancelled = b;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlayerEnterPlotEvent.java

@@ -0,0 +1,40 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.player.PlayerEvent;
+
+public class PlayerEnterPlotEvent extends PlayerEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final Plot plot;
+
+    /**
+     * Called when a player leaves a plot.
+     *
+     * @param player Player that entered the plot
+     * @param plot   Plot that was entered
+     */
+    public PlayerEnterPlotEvent(Player player, Plot plot) {
+        super(player);
+        this.plot = plot;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Get the plot involved.
+     *
+     * @return Plot
+     */
+    public Plot getPlot() {
+        return this.plot;
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlayerLeavePlotEvent.java

@@ -0,0 +1,43 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.player.PlayerEvent;
+
+/**
+ *
+ */
+public class PlayerLeavePlotEvent extends PlayerEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final Plot plot;
+
+    /**
+     * PlayerLeavePlotEvent: Called when a player leaves a plot
+     *
+     * @param player Player that left the plot
+     * @param plot   Plot that was left
+     */
+    public PlayerLeavePlotEvent(Player player, Plot plot) {
+        super(player);
+        this.plot = plot;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Get the plot involved
+     *
+     * @return Plot
+     */
+    public Plot getPlot() {
+        return this.plot;
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlayerPlotDeniedEvent.java

@@ -0,0 +1,65 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+
+import java.util.UUID;
+
+public class PlayerPlotDeniedEvent extends PlotEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final Player initiator;
+    private final boolean added;
+    private final UUID player;
+
+    /**
+     * PlayerPlotDeniedEvent: Called when the denied UUID list is modified for a plot.
+     *
+     * @param initiator Player that initiated the event
+     * @param plot      Plot in which the event occurred
+     * @param player    Player that was denied/un-denied
+     * @param added     true of add to deny list, false if removed
+     */
+    public PlayerPlotDeniedEvent(Player initiator, Plot plot, UUID player, boolean added) {
+        super(plot);
+        this.initiator = initiator;
+        this.added = added;
+        this.player = player;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * If a user was added.
+     *
+     * @return boolean
+     */
+    public boolean wasAdded() {
+        return this.added;
+    }
+
+    /**
+     * The player added/removed.
+     *
+     * @return UUID
+     */
+    public UUID getPlayer() {
+        return this.player;
+    }
+
+    /**
+     * The player initiating the action.
+     *
+     * @return Player
+     */
+    public Player getInitiator() {
+        return this.initiator;
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlayerPlotHelperEvent.java

@@ -0,0 +1,68 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+
+import java.util.UUID;
+
+/**
+ *
+ */
+public class PlayerPlotHelperEvent extends PlotEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final Player initiator;
+    private final boolean added;
+    private final UUID player;
+
+    /**
+     * PlayerPlotHelperEvent: Called when a plot helper is added/removed
+     *
+     * @param initiator Player that initiated the event
+     * @param plot      Plot in which the event occurred
+     * @param player    Player that was added/removed from the helper list
+     * @param added     true of the player was added, false if the player was removed
+     */
+    public PlayerPlotHelperEvent(Player initiator, Plot plot, UUID player, boolean added) {
+        super(plot);
+        this.initiator = initiator;
+        this.added = added;
+        this.player = player;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * If a player was added
+     *
+     * @return boolean
+     */
+    public boolean wasAdded() {
+        return this.added;
+    }
+
+    /**
+     * The UUID added/removed
+     *
+     * @return UUID
+     */
+    public UUID getPlayer() {
+        return this.player;
+    }
+
+    /**
+     * The player initiating the action
+     *
+     * @return Player
+     */
+    public Player getInitiator() {
+        return this.initiator;
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlayerPlotTrustedEvent.java

@@ -0,0 +1,65 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+
+import java.util.UUID;
+
+public class PlayerPlotTrustedEvent extends PlotEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final Player initiator;
+    private final boolean added;
+    private final UUID player;
+
+    /**
+     * PlayerPlotTrustedEvent: Called when a plot trusted user is added/removed
+     *
+     * @param initiator Player that initiated the event
+     * @param plot      Plot in which the event occurred
+     * @param player    Player that was added/removed from the trusted list
+     * @param added     true of the player was added, false if the player was removed
+     */
+    public PlayerPlotTrustedEvent(Player initiator, Plot plot, UUID player, boolean added) {
+        super(plot);
+        this.initiator = initiator;
+        this.added = added;
+        this.player = player;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * If a player was added
+     *
+     * @return boolean
+     */
+    public boolean wasAdded() {
+        return this.added;
+    }
+
+    /**
+     * The UUID added/removed
+     *
+     * @return UUID
+     */
+    public UUID getPlayer() {
+        return this.player;
+    }
+
+    /**
+     * The player initiating the action
+     *
+     * @return Player
+     */
+    public Player getInitiator() {
+        return this.initiator;
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlayerTeleportToPlotEvent.java

@@ -0,0 +1,66 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.object.Location;
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.player.PlayerEvent;
+
+/**
+ * Called when a player teleports to a plot
+ */
+public class PlayerTeleportToPlotEvent extends PlayerEvent implements Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final Location from;
+    private final Plot plot;
+    private boolean cancelled;
+
+    /**
+     * PlayerTeleportToPlotEvent: Called when a player teleports to a plot
+     *
+     * @param player That was teleported
+     * @param from   Start location
+     * @param plot   Plot to which the player was teleported
+     */
+    public PlayerTeleportToPlotEvent(Player player, Location from, Plot plot) {
+        super(player);
+        this.from = from;
+        this.plot = plot;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    /**
+     * Get the from location
+     *
+     * @return Location
+     */
+    public Location getFrom() {
+        return this.from;
+    }
+
+    /**
+     * Get the plot involved
+     *
+     * @return Plot
+     */
+    public Plot getPlot() {
+        return this.plot;
+    }
+
+    @Override public boolean isCancelled() {
+        return this.cancelled;
+    }
+
+    @Override public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlotAutoMergeEvent.java

@@ -0,0 +1,56 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.object.PlotId;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.World;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Event called when plots are automatically merged with /plot auto
+ * {@inheritDoc}
+ */
+public final class PlotAutoMergeEvent extends PlotEvent implements Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final List<PlotId> plots;
+    @Getter private final World world;
+    @Getter @Setter private boolean cancelled;
+
+    /**
+     * PlotAutoMergeEvent: Called when plots are automatically merged with /plot auto
+     *
+     * @param world World in which the event occurred
+     * @param plot  Plot that was merged
+     * @param plots A list of plots involved in the event
+     */
+    public PlotAutoMergeEvent(@NotNull final World world, @NotNull final Plot plot,
+        @NotNull final List<PlotId> plots) {
+        super(plot);
+        this.world = world;
+        this.plots = plots;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Get the plots being added.
+     *
+     * @return Unmodifiable list containing the merging plots
+     */
+    public List<PlotId> getPlots() {
+        return Collections.unmodifiableList(this.plots);
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlotChangeOwnerEvent.java

@@ -0,0 +1,105 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.object.PlotId;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+
+import java.util.UUID;
+
+public class PlotChangeOwnerEvent extends PlotEvent implements Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final Player initiator;
+    private final UUID newOwner;
+    private final UUID oldOwner;
+    private boolean hasOldOwner;
+    private boolean cancelled;
+
+    /**
+     * PlotChangeOwnerEvent: Called when a plot's owner is change.
+     *
+     * @param newOwner The new owner of the plot
+     * @param oldOwner The old owner of the plot
+     * @param plot     The plot having its owner changed
+     */
+    public PlotChangeOwnerEvent(Player initiator, Plot plot, UUID oldOwner, UUID newOwner,
+        boolean hasOldOwner) {
+        super(plot);
+        this.initiator = initiator;
+        this.newOwner = newOwner;
+        this.oldOwner = oldOwner;
+        this.hasOldOwner = hasOldOwner;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Get the PlotId.
+     *
+     * @return PlotId
+     */
+    public PlotId getPlotId() {
+        return getPlot().getId();
+    }
+
+    /**
+     * Get the world name.
+     *
+     * @return String
+     */
+    public String getWorld() {
+        return getPlot().getWorldName();
+    }
+
+    /**
+     * Get the change-owner initator
+     *
+     * @return Player
+     */
+    public Player getInitiator() {
+        return this.initiator;
+    }
+
+    /**
+     * Get the old owner of the plot. Null if not exists.
+     *
+     * @return UUID
+     */
+    public UUID getOldOwner() {
+        return this.oldOwner;
+    }
+
+    /**
+     * Get the new owner of the plot
+     *
+     * @return UUID
+     */
+    public UUID getNewOwner() {
+        return this.newOwner;
+    }
+
+    /**
+     * Get if the plot had an old owner
+     *
+     * @return boolean
+     */
+    public boolean hasOldOwner() {
+        return this.hasOldOwner;
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    @Override public boolean isCancelled() {
+        return this.cancelled;
+    }
+
+    @Override public void setCancelled(boolean b) {
+        this.cancelled = b;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlotClearEvent.java

@@ -0,0 +1,53 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.object.PlotId;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Called when a plot is cleared
+ */
+public class PlotClearEvent extends PlotEvent implements Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+    private boolean cancelled;
+
+    public PlotClearEvent(Plot plot) {
+        super(plot);
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Get the PlotId.
+     *
+     * @return PlotId
+     */
+    public PlotId getPlotId() {
+        return getPlot().getId();
+    }
+
+    /**
+     * Get the world name.
+     *
+     * @return String
+     */
+    public String getWorld() {
+        return getPlot().getWorldName();
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    @Override public boolean isCancelled() {
+        return this.cancelled;
+    }
+
+    @Override public void setCancelled(boolean b) {
+        this.cancelled = b;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlotComponentSetEvent.java

@@ -0,0 +1,54 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.object.PlotId;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Called when a plot component is set
+ */
+public class PlotComponentSetEvent extends PlotEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final String component;
+
+    public PlotComponentSetEvent(Plot plot, String component) {
+        super(plot);
+        this.component = component;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Get the PlotId
+     *
+     * @return PlotId
+     */
+    public PlotId getPlotId() {
+        return getPlot().getId();
+    }
+
+    /**
+     * Get the world name
+     *
+     * @return String
+     */
+    public String getWorld() {
+        return getPlot().getWorldName();
+    }
+
+    /**
+     * Get the component which was set
+     *
+     * @return Component name
+     */
+    public String getComponent() {
+        return this.component;
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlotDeleteEvent.java

@@ -0,0 +1,53 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.object.PlotId;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Called when a plot is deleted
+ */
+public class PlotDeleteEvent extends PlotEvent implements Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+    private boolean cancelled;
+
+    public PlotDeleteEvent(Plot plot) {
+        super(plot);
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Get the PlotId.
+     *
+     * @return PlotId
+     */
+    public PlotId getPlotId() {
+        return getPlot().getId();
+    }
+
+    /**
+     * Get the world name.
+     *
+     * @return String
+     */
+    public String getWorld() {
+        return getPlot().getWorldName();
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    @Override public boolean isCancelled() {
+        return this.cancelled;
+    }
+
+    @Override public void setCancelled(boolean b) {
+        this.cancelled = b;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlotEvent.java

@@ -1,14 +1,13 @@
-package com.plotsquared.bukkit.events;
+package com.github.intellectualsites.plotsquared.bukkit.events;
 
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
 import org.bukkit.event.Event;
 
-import com.intellectualcrafters.plot.object.Plot;
-
 public abstract class PlotEvent extends Event {
 
     private final Plot plot;
 
-    public PlotEvent(final Plot plot) {
+    public PlotEvent(Plot plot) {
         this.plot = plot;
     }
 

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlotFlagAddEvent.java

@@ -0,0 +1,52 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.flag.Flag;
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Called when a Flag is added to a plot.
+ */
+public class PlotFlagAddEvent extends PlotEvent implements Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final Flag flag;
+    private boolean cancelled;
+
+    /**
+     * PlotFlagAddEvent: Called when a Flag is added to a plot.
+     *
+     * @param flag Flag that was added
+     * @param plot Plot to which the flag was added
+     */
+    public PlotFlagAddEvent(Flag flag, Plot plot) {
+        super(plot);
+        this.flag = flag;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Get the flag involved.
+     *
+     * @return Flag
+     */
+    public Flag getFlag() {
+        return this.flag;
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    @Override public final boolean isCancelled() {
+        return this.cancelled;
+    }
+
+    @Override public final void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlotFlagRemoveEvent.java

@@ -0,0 +1,52 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.flag.Flag;
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Called when a flag is removed from a plot
+ */
+public class PlotFlagRemoveEvent extends PlotEvent implements Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final Flag flag;
+    private boolean cancelled;
+
+    /**
+     * PlotFlagRemoveEvent: Called when a flag is removed from a plot
+     *
+     * @param flag Flag that was removed
+     * @param plot Plot from which the flag was removed
+     */
+    public PlotFlagRemoveEvent(Flag flag, Plot plot) {
+        super(plot);
+        this.flag = flag;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Get the flag involved
+     *
+     * @return Flag
+     */
+    public Flag getFlag() {
+        return this.flag;
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    @Override public final boolean isCancelled() {
+        return this.cancelled;
+    }
+
+    @Override public final void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlotMergeEvent.java

@@ -0,0 +1,46 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.World;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Event called when several plots are merged
+ * {@inheritDoc}
+ */
+public final class PlotMergeEvent extends PlotEvent implements Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+    @Getter private final int dir;
+    @Getter private final int max;
+    @Getter private final World world;
+    @Getter @Setter private boolean cancelled;
+
+    /**
+     * PlotMergeEvent: Called when plots are merged
+     *
+     * @param world World in which the event occurred
+     * @param plot  Plot that was merged
+     * @param dir   The direction of the merge
+     * @param max   Max merge size
+     */
+    public PlotMergeEvent(@NotNull final World world, @NotNull final Plot plot,
+        @NotNull final int dir, @NotNull final int max) {
+        super(plot);
+        this.world = world;
+        this.dir = dir;
+        this.max = max;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlotRateEvent.java

@@ -0,0 +1,49 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.Rating;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+
+public class PlotRateEvent extends PlotEvent implements Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final PlotPlayer rater;
+    private Rating rating;
+    private boolean cancelled = false;
+
+    public PlotRateEvent(PlotPlayer rater, Rating rating, Plot plot) {
+        super(plot);
+        this.rater = rater;
+        this.rating = rating;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    public PlotPlayer getRater() {
+        return this.rater;
+    }
+
+    public Rating getRating() {
+        return this.rating;
+    }
+
+    public void setRating(Rating rating) {
+        this.rating = rating;
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    @Override public boolean isCancelled() {
+        return this.cancelled;
+    }
+
+    @Override public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/events/PlotUnlinkEvent.java

@@ -0,0 +1,57 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.object.PlotArea;
+import com.github.intellectualsites.plotsquared.plot.object.PlotId;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.World;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Event called when several merged plots are unlinked
+ * {@inheritDoc}
+ */
+public final class PlotUnlinkEvent extends Event implements Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final List<PlotId> plots;
+    @Getter private final World world;
+    @Getter private final PlotArea area;
+    @Getter @Setter private boolean cancelled;
+
+    /**
+     * Called when a mega-plot is unlinked.
+     *
+     * @param world World in which the event occurred
+     * @param plots Plots that are involved in the event
+     */
+    public PlotUnlinkEvent(@NotNull final World world, @NotNull final PlotArea area,
+        @NotNull final List<PlotId> plots) {
+        this.plots = plots;
+        this.world = world;
+        this.area = area;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Get the plots involved.
+     *
+     * @return Unmodifiable list containing {@link PlotId PlotIds} of the plots involved
+     */
+    public List<PlotId> getPlots() {
+        return Collections.unmodifiableList(this.plots);
+    }
+
+    @Override public HandlerList getHandlers() {
+        return handlers;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/generator/BukkitAugmentedGenerator.java

@@ -0,0 +1,32 @@
+package com.github.intellectualsites.plotsquared.bukkit.generator;
+
+import com.github.intellectualsites.plotsquared.plot.generator.AugmentedUtils;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.generator.BlockPopulator;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Random;
+
+public class BukkitAugmentedGenerator extends BlockPopulator {
+
+    private static BukkitAugmentedGenerator generator;
+
+    public static BukkitAugmentedGenerator get(World world) {
+        for (BlockPopulator populator : world.getPopulators()) {
+            if (populator instanceof BukkitAugmentedGenerator) {
+                return (BukkitAugmentedGenerator) populator;
+            }
+        }
+        if (generator == null) {
+            generator = new BukkitAugmentedGenerator();
+        }
+        world.getPopulators().add(generator);
+        return generator;
+    }
+
+    @Override
+    public void populate(@NotNull World world, @NotNull Random random, @NotNull Chunk source) {
+        AugmentedUtils.generate(world.getName(), source.getX(), source.getZ(), null);
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/generator/BukkitPlotGenerator.java

@@ -0,0 +1,211 @@
+package com.github.intellectualsites.plotsquared.bukkit.generator;
+
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitUtil;
+import com.github.intellectualsites.plotsquared.bukkit.util.block.GenChunk;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.generator.GeneratorWrapper;
+import com.github.intellectualsites.plotsquared.plot.generator.IndependentPlotGenerator;
+import com.github.intellectualsites.plotsquared.plot.object.ChunkWrapper;
+import com.github.intellectualsites.plotsquared.plot.object.PlotArea;
+import com.github.intellectualsites.plotsquared.plot.object.worlds.SingleWorldGenerator;
+import com.github.intellectualsites.plotsquared.plot.util.ChunkManager;
+import com.github.intellectualsites.plotsquared.plot.util.MainUtil;
+import com.github.intellectualsites.plotsquared.plot.util.block.ScopedLocalBlockQueue;
+import com.sk89q.worldedit.math.BlockVector2;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.generator.BlockPopulator;
+import org.bukkit.generator.ChunkGenerator;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class BukkitPlotGenerator extends ChunkGenerator
+    implements GeneratorWrapper<ChunkGenerator> {
+
+    @SuppressWarnings("unused") public final boolean PAPER_ASYNC_SAFE = true;
+
+    private final IndependentPlotGenerator plotGenerator;
+    private final ChunkGenerator platformGenerator;
+    private final boolean full;
+    private List<BlockPopulator> populators;
+    private boolean loaded = false;
+
+    public BukkitPlotGenerator(IndependentPlotGenerator generator) {
+        if (generator == null) {
+            throw new IllegalArgumentException("Generator may not be null!");
+        }
+        this.plotGenerator = generator;
+        this.platformGenerator = this;
+        this.populators = new ArrayList<>();
+        this.populators.add(new BlockStatePopulator(this.plotGenerator));
+        this.full = true;
+        MainUtil.initCache();
+    }
+
+    public BukkitPlotGenerator(final String world, final ChunkGenerator cg) {
+        if (cg instanceof BukkitPlotGenerator) {
+            throw new IllegalArgumentException("ChunkGenerator: " + cg.getClass().getName()
+                + " is already a BukkitPlotGenerator!");
+        }
+        this.full = false;
+        this.platformGenerator = cg;
+        this.plotGenerator = new DelegatePlotGenerator(cg, world);
+        MainUtil.initCache();
+    }
+
+    @Override public void augment(PlotArea area) {
+        BukkitAugmentedGenerator.get(BukkitUtil.getWorld(area.worldname));
+    }
+
+    @Override public boolean isFull() {
+        return this.full;
+    }
+
+    @Override public IndependentPlotGenerator getPlotGenerator() {
+        return this.plotGenerator;
+    }
+
+    @Override public ChunkGenerator getPlatformGenerator() {
+        return this.platformGenerator;
+    }
+
+    @Override
+    @NotNull
+    public List<BlockPopulator> getDefaultPopulators(@NotNull World world) {
+        try {
+            if (!this.loaded) {
+                String name = world.getName();
+                PlotSquared.get().loadWorld(name, this);
+                Set<PlotArea> areas = PlotSquared.get().getPlotAreas(name);
+                if (!areas.isEmpty()) {
+                    PlotArea area = areas.iterator().next();
+                    if (!area.MOB_SPAWNING) {
+                        if (!area.SPAWN_EGGS) {
+                            world.setSpawnFlags(false, false);
+                        }
+                        world.setAmbientSpawnLimit(0);
+                        world.setAnimalSpawnLimit(0);
+                        world.setMonsterSpawnLimit(0);
+                        world.setWaterAnimalSpawnLimit(0);
+                    } else {
+                        world.setSpawnFlags(true, true);
+                        world.setAmbientSpawnLimit(-1);
+                        world.setAnimalSpawnLimit(-1);
+                        world.setMonsterSpawnLimit(-1);
+                        world.setWaterAnimalSpawnLimit(-1);
+                    }
+                }
+                this.loaded = true;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        ArrayList<BlockPopulator> toAdd = new ArrayList<>();
+        List<BlockPopulator> existing = world.getPopulators();
+        if (populators == null && platformGenerator != null) {
+            populators = new ArrayList<>(platformGenerator.getDefaultPopulators(world));
+        }
+        if (populators != null) {
+            for (BlockPopulator populator : this.populators) {
+                if (!existing.contains(populator)) {
+                    toAdd.add(populator);
+                }
+            }
+        }
+        return toAdd;
+    }
+
+    @Override
+    @NotNull
+    public ChunkData generateChunkData(@NotNull World world, @NotNull Random random, int x, int z,
+        @NotNull BiomeGrid biome) {
+
+        GenChunk result = new GenChunk();
+        if (this.getPlotGenerator() instanceof SingleWorldGenerator) {
+            if (result.getChunkData() != null) {
+                for (int chunkX = 0; chunkX < 16; chunkX++) {
+                    for (int chunkZ = 0; chunkZ < 16; chunkZ++) {
+                        biome.setBiome(chunkX, chunkZ, Biome.PLAINS);
+                    }
+                }
+                return result.getChunkData();
+            }
+        }
+        // Set the chunk location
+        result.setChunk(new ChunkWrapper(world.getName(), x, z));
+        // Set the result data
+        result.setChunkData(createChunkData(world));
+        result.biomeGrid = biome;
+        result.result = null;
+
+        // Catch any exceptions (as exceptions usually thrown)
+        try {
+            // Fill the result data if necessary
+            if (this.platformGenerator != this) {
+                return this.platformGenerator.generateChunkData(world, random, x, z, biome);
+            } else {
+                generate(BlockVector2.at(x, z), world, result);
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+        // Return the result data
+        return result.getChunkData();
+    }
+
+    private void generate(BlockVector2 loc, World world, ScopedLocalBlockQueue result) {
+        // Load if improperly loaded
+        if (!this.loaded) {
+            String name = world.getName();
+            PlotSquared.get().loadWorld(name, this);
+            this.loaded = true;
+        }
+        // Process the chunk
+        if (ChunkManager.preProcessChunk(loc, result)) {
+            return;
+        }
+        PlotArea area = PlotSquared.get().getPlotArea(world.getName(), null);
+        try {
+            this.plotGenerator.generateChunk(result, area);
+        } catch (Throwable e) {
+            // Recover from generator error
+            e.printStackTrace();
+        }
+        ChunkManager.postProcessChunk(loc, result);
+    }
+
+    /**
+     * Allow spawning everywhere.
+     *
+     * @param world Ignored
+     * @param x     Ignored
+     * @param z     Ignored
+     * @return always true
+     */
+    @Override public boolean canSpawn(@NotNull final World world, final int x, final int z) {
+        return true;
+    }
+
+    @Override public String toString() {
+        if (this.platformGenerator == this) {
+            return this.plotGenerator.getName();
+        }
+        if (this.platformGenerator == null) {
+            return "null";
+        } else {
+            return this.platformGenerator.getClass().getName();
+        }
+    }
+
+    @Override public boolean equals(final Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        return toString().equals(obj.toString()) || toString().equals(obj.getClass().getName());
+    }
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/generator/DelegatePlotGenerator.java

@@ -0,0 +1,64 @@
+package com.github.intellectualsites.plotsquared.bukkit.generator;
+
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitUtil;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.generator.IndependentPlotGenerator;
+import com.github.intellectualsites.plotsquared.plot.object.Location;
+import com.github.intellectualsites.plotsquared.plot.object.PlotArea;
+import com.github.intellectualsites.plotsquared.plot.object.PlotId;
+import com.github.intellectualsites.plotsquared.plot.util.MathMan;
+import com.github.intellectualsites.plotsquared.plot.util.block.ScopedLocalBlockQueue;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import lombok.RequiredArgsConstructor;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.generator.BlockPopulator;
+import org.bukkit.generator.ChunkGenerator;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Range;
+
+import java.util.Random;
+
+@RequiredArgsConstructor final class DelegatePlotGenerator extends IndependentPlotGenerator {
+
+    private final ChunkGenerator chunkGenerator;
+    private final String world;
+
+    @Override public void initialize(PlotArea area) {
+    }
+
+    @Override public String getName() {
+        return this.chunkGenerator.getClass().getName();
+    }
+
+    @Override public PlotArea getNewPlotArea(String world, String id, PlotId min, PlotId max) {
+        return PlotSquared.get().IMP.getDefaultGenerator().getNewPlotArea(world, id, min, max);
+    }
+
+    @Override public void generateChunk(final ScopedLocalBlockQueue result, PlotArea settings) {
+        World world = BukkitUtil.getWorld(this.world);
+        Location min = result.getMin();
+        int chunkX = min.getX() >> 4;
+        int chunkZ = min.getZ() >> 4;
+        Random random = new Random(MathMan.pair((short) chunkX, (short) chunkZ));
+        try {
+            ChunkGenerator.BiomeGrid grid = new ChunkGenerator.BiomeGrid() {
+                @Override public void setBiome(@Range(from = 0, to = 15) int x,
+                    @Range(from = 0, to = 15) int z, Biome biome) {
+                    result.setBiome(x, z, BukkitAdapter.adapt(biome));
+                }
+
+                @Override @NotNull public Biome getBiome(int x, int z) {
+                    return Biome.FOREST;
+                }
+            };
+            chunkGenerator.generateChunkData(world, random, chunkX, chunkZ, grid);
+            return;
+        } catch (Throwable ignored) {
+        }
+        for (BlockPopulator populator : chunkGenerator.getDefaultPopulators(world)) {
+            populator.populate(world, random, world.getChunkAt(chunkX, chunkZ));
+        }
+    }
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/generator/PlotBlockPopulator.java

@@ -0,0 +1,36 @@
+package com.github.intellectualsites.plotsquared.bukkit.generator;
+
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.generator.IndependentPlotGenerator;
+import com.github.intellectualsites.plotsquared.plot.object.ChunkWrapper;
+import com.github.intellectualsites.plotsquared.plot.object.PlotArea;
+import com.github.intellectualsites.plotsquared.plot.util.block.GlobalBlockQueue;
+import com.github.intellectualsites.plotsquared.plot.util.block.LocalBlockQueue;
+import com.github.intellectualsites.plotsquared.plot.util.block.ScopedLocalBlockQueue;
+import lombok.RequiredArgsConstructor;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.generator.BlockPopulator;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Random;
+
+@RequiredArgsConstructor final class BlockStatePopulator extends BlockPopulator {
+
+    private final IndependentPlotGenerator plotGenerator;
+    private LocalBlockQueue queue;
+
+    @Override public void populate(@NotNull final World world, @NotNull final Random random,
+        @NotNull final Chunk source) {
+        if (this.queue == null) {
+            this.queue = GlobalBlockQueue.IMP.getNewQueue(world.getName(), false);
+        }
+        final PlotArea area = PlotSquared.get().getPlotArea(world.getName(), null);
+        final ChunkWrapper wrap = new ChunkWrapper(area.worldname, source.getX(), source.getZ());
+        final ScopedLocalBlockQueue chunk = this.queue.getForChunk(wrap.x, wrap.z);
+        if (this.plotGenerator.populateChunk(chunk, area)) {
+            this.queue.flush();
+        }
+    }
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/listeners/ChunkListener.java

@@ -0,0 +1,283 @@
+package com.github.intellectualsites.plotsquared.bukkit.listeners;
+
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.config.Settings;
+import com.github.intellectualsites.plotsquared.plot.object.Location;
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.RefClass;
+import com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.RefField;
+import com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.RefMethod;
+import com.github.intellectualsites.plotsquared.plot.util.TaskManager;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.BlockState;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockPhysicsEvent;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.event.entity.ItemSpawnEvent;
+import org.bukkit.event.world.ChunkLoadEvent;
+import org.bukkit.event.world.ChunkUnloadEvent;
+
+import java.lang.reflect.Method;
+import java.util.HashSet;
+
+import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.getRefClass;
+
+@SuppressWarnings("unused") public class ChunkListener implements Listener {
+
+    private RefMethod methodGetHandleChunk;
+    private RefField mustSave;
+    private Chunk lastChunk;
+    private boolean ignoreUnload = false;
+
+    public ChunkListener() {
+        if (Settings.Chunk_Processor.AUTO_TRIM) {
+            try {
+                RefClass classChunk = getRefClass("{nms}.Chunk");
+                RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
+                this.mustSave = classChunk.getField("mustSave");
+                this.methodGetHandleChunk = classCraftChunk.getMethod("getHandle");
+            } catch (Throwable ignored) {
+                PlotSquared.debug(PlotSquared.get().IMP.getPluginName()
+                    + "/Server not compatible for chunk processor trim/gc");
+
+                Settings.Chunk_Processor.AUTO_TRIM = false;
+            }
+        }
+        if (!Settings.Chunk_Processor.AUTO_TRIM) {
+            return;
+        }
+        for (World world : Bukkit.getWorlds()) {
+            world.setAutoSave(false);
+        }
+        TaskManager.runTaskRepeat(() -> {
+            try {
+                HashSet<Chunk> toUnload = new HashSet<>();
+                for (World world : Bukkit.getWorlds()) {
+                    String worldName = world.getName();
+                    if (!PlotSquared.get().hasPlotArea(worldName)) {
+                        continue;
+                    }
+                    Object w = world.getClass().getDeclaredMethod("getHandle").invoke(world);
+                    Object chunkMap = w.getClass().getDeclaredMethod("getPlayerChunkMap").invoke(w);
+                    Method methodIsChunkInUse =
+                        chunkMap.getClass().getDeclaredMethod("isChunkInUse", int.class, int.class);
+                    Chunk[] chunks = world.getLoadedChunks();
+                    for (Chunk chunk : chunks) {
+                        if ((boolean) methodIsChunkInUse
+                            .invoke(chunkMap, chunk.getX(), chunk.getZ())) {
+                            continue;
+                        }
+                        int x = chunk.getX();
+                        int z = chunk.getZ();
+                        if (!shouldSave(worldName, x, z)) {
+                            unloadChunk(worldName, chunk, false);
+                            continue;
+                        }
+                        toUnload.add(chunk);
+                    }
+                }
+                if (toUnload.isEmpty()) {
+                    return;
+                }
+                long start = System.currentTimeMillis();
+                for (Chunk chunk : toUnload) {
+                    if (System.currentTimeMillis() - start > 5) {
+                        return;
+                    }
+                    chunk.unload(true);
+                }
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        }, 1);
+    }
+
+    public boolean unloadChunk(String world, Chunk chunk, boolean safe) {
+        if (safe && shouldSave(world, chunk.getX(), chunk.getZ())) {
+            return false;
+        }
+        Object c = this.methodGetHandleChunk.of(chunk).call();
+        RefField.RefExecutor field = this.mustSave.of(c);
+        if ((Boolean) field.get()) {
+            field.set(false);
+            if (chunk.isLoaded()) {
+                ignoreUnload = true;
+                chunk.unload(false);
+                ignoreUnload = false;
+            }
+        }
+        return true;
+    }
+
+    public boolean shouldSave(String world, int chunkX, int chunkZ) {
+        int x = chunkX << 4;
+        int z = chunkZ << 4;
+        int x2 = x + 15;
+        int z2 = z + 15;
+        Plot plot = new Location(world, x, 1, z).getOwnedPlotAbs();
+        if (plot != null && plot.hasOwner()) {
+            return true;
+        }
+        plot = new Location(world, x2, 1, z2).getOwnedPlotAbs();
+        if (plot != null && plot.hasOwner()) {
+            return true;
+        }
+        plot = new Location(world, x2, 1, z).getOwnedPlotAbs();
+        if (plot != null && plot.hasOwner()) {
+            return true;
+        }
+        plot = new Location(world, x, 1, z2).getOwnedPlotAbs();
+        if (plot != null && plot.hasOwner()) {
+            return true;
+        }
+        plot = new Location(world, x + 7, 1, z + 7).getOwnedPlotAbs();
+        return plot != null && plot.hasOwner();
+    }
+
+    @EventHandler public void onChunkUnload(ChunkUnloadEvent event) {
+        if (ignoreUnload) {
+            return;
+        }
+        Chunk chunk = event.getChunk();
+        if (Settings.Chunk_Processor.AUTO_TRIM) {
+            String world = chunk.getWorld().getName();
+            if (PlotSquared.get().hasPlotArea(world)) {
+                if (unloadChunk(world, chunk, true)) {
+                    return;
+                }
+            }
+        }
+        if (processChunk(event.getChunk(), true)) {
+            chunk.setForceLoaded(true);
+        }
+    }
+
+    @EventHandler public void onChunkLoad(ChunkLoadEvent event) {
+        processChunk(event.getChunk(), false);
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST) public void onItemSpawn(ItemSpawnEvent event) {
+        Item entity = event.getEntity();
+        PaperLib.getChunkAtAsync(event.getLocation()).thenAccept(chunk -> {
+            if (chunk == this.lastChunk) {
+                event.getEntity().remove();
+                event.setCancelled(true);
+                return;
+            }
+            if (!PlotSquared.get().hasPlotArea(chunk.getWorld().getName())) {
+                return;
+            }
+            Entity[] entities = chunk.getEntities();
+            if (entities.length > Settings.Chunk_Processor.MAX_ENTITIES) {
+                event.getEntity().remove();
+                event.setCancelled(true);
+                this.lastChunk = chunk;
+            } else {
+                this.lastChunk = null;
+            }
+        });
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onBlockPhysics(BlockPhysicsEvent event) {
+        if (Settings.Chunk_Processor.DISABLE_PHYSICS) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onEntitySpawn(CreatureSpawnEvent event) {
+        LivingEntity entity = event.getEntity();
+        PaperLib.getChunkAtAsync(event.getLocation()).thenAccept(chunk -> {
+            if (chunk == this.lastChunk) {
+                event.getEntity().remove();
+                event.setCancelled(true);
+                return;
+            }
+            if (!PlotSquared.get().hasPlotArea(chunk.getWorld().getName())) {
+                return;
+            }
+            Entity[] entities = chunk.getEntities();
+            if (entities.length > Settings.Chunk_Processor.MAX_ENTITIES) {
+                event.getEntity().remove();
+                event.setCancelled(true);
+                this.lastChunk = chunk;
+            } else {
+                this.lastChunk = null;
+            }
+        });
+    }
+
+    private void cleanChunk(final Chunk chunk) {
+        TaskManager.index.incrementAndGet();
+        final Integer currentIndex = TaskManager.index.get();
+        Integer task = TaskManager.runTaskRepeat(() -> {
+            if (!chunk.isLoaded()) {
+                Bukkit.getScheduler().cancelTask(TaskManager.tasks.get(currentIndex));
+                TaskManager.tasks.remove(currentIndex);
+                PlotSquared.debug("Successfully processed and unloaded chunk!");
+                chunk.unload(true);
+                return;
+            }
+            BlockState[] tiles = chunk.getTileEntities();
+            if (tiles.length == 0) {
+                Bukkit.getScheduler().cancelTask(TaskManager.tasks.get(currentIndex));
+                TaskManager.tasks.remove(currentIndex);
+                PlotSquared.debug("Successfully processed and unloaded chunk!");
+                chunk.unload(true);
+                return;
+            }
+            long start = System.currentTimeMillis();
+            int i = 0;
+            while (System.currentTimeMillis() - start < 250) {
+                if (i >= tiles.length) {
+                    Bukkit.getScheduler().cancelTask(TaskManager.tasks.get(currentIndex));
+                    TaskManager.tasks.remove(currentIndex);
+                    PlotSquared.debug("Successfully processed and unloaded chunk!");
+                    chunk.unload(true);
+                    return;
+                }
+                tiles[i].getBlock().setType(Material.AIR, false);
+                i++;
+            }
+        }, 5);
+        TaskManager.tasks.put(currentIndex, task);
+    }
+
+    public boolean processChunk(Chunk chunk, boolean unload) {
+        if (!PlotSquared.get().hasPlotArea(chunk.getWorld().getName())) {
+            return false;
+        }
+        Entity[] entities = chunk.getEntities();
+        BlockState[] tiles = chunk.getTileEntities();
+        if (entities.length > Settings.Chunk_Processor.MAX_ENTITIES) {
+            for (Entity ent : entities) {
+                if (!(ent instanceof Player)) {
+                    ent.remove();
+                }
+            }
+            PlotSquared.debug("PlotSquared detected unsafe chunk and processed: " + (chunk.getX() << 4) + "," + (chunk.getX() << 4));
+        }
+        if (tiles.length > Settings.Chunk_Processor.MAX_TILES) {
+            if (unload) {
+                PlotSquared.debug("PlotSquared detected unsafe chunk: " + (chunk.getX()<< 4) + "," + (chunk.getX() << 4));
+                cleanChunk(chunk);
+                return true;
+            }
+            for (BlockState tile : tiles) {
+                tile.getBlock().setType(Material.AIR, false);
+            }
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/listeners/EntitySpawnListener.java

@@ -0,0 +1,173 @@
+package com.github.intellectualsites.plotsquared.bukkit.listeners;
+
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitUtil;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.config.Settings;
+import com.github.intellectualsites.plotsquared.plot.flag.Flags;
+import com.github.intellectualsites.plotsquared.plot.object.Location;
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.object.PlotArea;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.entity.ArmorStand;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Vehicle;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.event.entity.EntitySpawnEvent;
+import org.bukkit.event.entity.EntityTeleportEvent;
+import org.bukkit.event.vehicle.VehicleBlockCollisionEvent;
+import org.bukkit.event.vehicle.VehicleCreateEvent;
+import org.bukkit.event.vehicle.VehicleMoveEvent;
+import org.bukkit.event.vehicle.VehicleUpdateEvent;
+import org.bukkit.event.world.ChunkLoadEvent;
+import org.bukkit.metadata.FixedMetadataValue;
+import org.bukkit.metadata.MetadataValue;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+public class EntitySpawnListener implements Listener {
+
+    private final static String KEY = "P2";
+    private static boolean ignoreTP = false;
+    private static boolean hasPlotArea = false;
+    private static String areaName = null;
+
+    public static void testNether(Entity entity) {
+        @NotNull World world = entity.getWorld();
+        if (world.getEnvironment() != World.Environment.NETHER
+            && world.getEnvironment() != World.Environment.THE_END) {
+            return;
+        }
+        test(entity);
+    }
+
+    public static void testCreate(Entity entity) {
+        @NotNull World world = entity.getWorld();
+        if (areaName == world.getName()) {
+        } else {
+            areaName = world.getName();
+            hasPlotArea = PlotSquared.get().hasPlotArea(areaName);
+        }
+        if (!hasPlotArea)
+            return;
+        test(entity);
+    }
+
+    public static void test(Entity entity) {
+        @NotNull World world = entity.getWorld();
+        List<MetadataValue> meta = entity.getMetadata(KEY);
+        if (meta.isEmpty()) {
+            if (PlotSquared.get().hasPlotArea(world.getName())) {
+                entity.setMetadata(KEY,
+                    new FixedMetadataValue((Plugin) PlotSquared.get().IMP, entity.getLocation()));
+            }
+        } else {
+            org.bukkit.Location origin = (org.bukkit.Location) meta.get(0).value();
+            World originWorld = origin.getWorld();
+            if (!originWorld.equals(world)) {
+                if (!ignoreTP) {
+                    if (!world.getName().equalsIgnoreCase(originWorld + "_the_end")) {
+                        try {
+                            ignoreTP = true;
+                            PaperLib.teleportAsync(entity,origin);
+                        } finally {
+                            ignoreTP = false;
+                        }
+                        if (entity.getLocation().getWorld().equals(world)) {
+                            entity.remove();
+                        }
+                    }
+                } else {
+                    entity.remove();
+                }
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void creatureSpawnEvent(EntitySpawnEvent event) {
+        Entity entity = event.getEntity();
+        Location location = BukkitUtil.getLocation(entity.getLocation());
+        PlotArea area = location.getPlotArea();
+        if (!location.isPlotArea()) {
+            return;
+        }
+        Plot plot = location.getOwnedPlotAbs();
+        if (plot == null) {
+            if (!area.MOB_SPAWNING) {
+                EntityType type = entity.getType();
+                switch (type) {
+                    case DROPPED_ITEM:
+                        if (Settings.Enabled_Components.KILL_ROAD_ITEMS) {
+                            event.setCancelled(true);
+                            break;
+                        }
+                    case PLAYER:
+                        return;
+                }
+                if (type.isAlive() || !area.MISC_SPAWN_UNOWNED) {
+                    event.setCancelled(true);
+                }
+            }
+            return;
+        }
+        if (Settings.Done.RESTRICT_BUILDING && plot.hasFlag(Flags.DONE)) {
+            event.setCancelled(true);
+        }
+        switch (entity.getType()) {
+            case ENDER_CRYSTAL:
+                if (PlayerEvents.checkEntity(entity, plot)) {
+                    event.setCancelled(true);
+                }
+            case SHULKER:
+                if (!entity.hasMetadata("shulkerPlot")) {
+                    entity.setMetadata("shulkerPlot",
+                        new FixedMetadataValue((Plugin) PlotSquared.get().IMP, plot.getId()));
+                }
+        }
+    }
+
+    @EventHandler public void onChunkLoad(ChunkLoadEvent event) {
+        @NotNull Chunk chunk = event.getChunk();
+        for (Entity entity : chunk.getEntities()) {
+            testCreate(entity);
+        }
+    }
+
+    @EventHandler public void onVehicle(VehicleUpdateEvent event) {
+        testNether(event.getVehicle());
+    }
+
+    @EventHandler public void onVehicle(VehicleCreateEvent event) {
+        testCreate(event.getVehicle());
+    }
+
+    @EventHandler public void onVehicle(VehicleBlockCollisionEvent event) {
+        testNether(event.getVehicle());
+    }
+
+    @EventHandler public void onTeleport(EntityTeleportEvent event) {
+        Entity ent = event.getEntity();
+        if (ent instanceof Vehicle || ent instanceof ArmorStand) {
+            testNether(event.getEntity());
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void vehicleMove(VehicleMoveEvent event) {
+        testNether(event.getVehicle());
+    }
+
+    @EventHandler public void spawn(CreatureSpawnEvent event) {
+        if (event.getEntityType() == EntityType.ARMOR_STAND) {
+            testCreate(event.getEntity());
+        }
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/listeners/ForceFieldListener.java

@@ -0,0 +1,106 @@
+package com.github.intellectualsites.plotsquared.bukkit.listeners;
+
+import com.github.intellectualsites.plotsquared.bukkit.object.BukkitPlayer;
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitUtil;
+import com.github.intellectualsites.plotsquared.plot.config.Captions;
+import com.github.intellectualsites.plotsquared.plot.flag.Flags;
+import com.github.intellectualsites.plotsquared.plot.object.Location;
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.util.Permissions;
+import com.google.common.collect.Iterables;
+import org.bukkit.entity.Player;
+import org.bukkit.util.Vector;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+@SuppressWarnings("unused") public class ForceFieldListener {
+
+    private static Set<PlotPlayer> getNearbyPlayers(Player player, Plot plot) {
+        Set<PlotPlayer> players = new HashSet<>();
+        for (Player nearPlayer : Iterables
+            .filter(player.getNearbyEntities(5d, 5d, 5d), Player.class)) {
+            PlotPlayer plotPlayer;
+            if ((plotPlayer = BukkitUtil.getPlayer(nearPlayer)) == null || !plot
+                .equals(plotPlayer.getCurrentPlot())) {
+                continue;
+            }
+            if (!plot.isAdded(plotPlayer.getUUID())) {
+                players.add(plotPlayer);
+            }
+        }
+        return players;
+    }
+
+    private static PlotPlayer hasNearbyPermitted(Player player, Plot plot) {
+        for (Player nearPlayer : Iterables
+            .filter(player.getNearbyEntities(5d, 5d, 5d), Player.class)) {
+            PlotPlayer plotPlayer;
+            if ((plotPlayer = BukkitUtil.getPlayer(nearPlayer)) == null || !plot
+                .equals(plotPlayer.getCurrentPlot())) {
+                continue;
+            }
+            if (plot.isAdded(plotPlayer.getUUID())) {
+                return plotPlayer;
+            }
+        }
+        return null;
+    }
+
+    private static Vector calculateVelocity(PlotPlayer player, PlotPlayer e) {
+        Location playerLocation = player.getLocationFull();
+        Location oPlayerLocation = e.getLocation();
+        double playerX = playerLocation.getX();
+        double playerY = playerLocation.getY();
+        double playerZ = playerLocation.getZ();
+        double oPlayerX = oPlayerLocation.getX();
+        double oPlayerY = oPlayerLocation.getY();
+        double oPlayerZ = oPlayerLocation.getZ();
+        double x = 0d;
+        if (playerX < oPlayerX) {
+            x = 1.0d;
+        } else if (playerX > oPlayerX) {
+            x = -1.0d;
+        }
+        double y = 0d;
+        if (playerY < oPlayerY) {
+            y = 0.5d;
+        } else if (playerY > oPlayerY) {
+            y = -0.5d;
+        }
+        double z = 0d;
+        if (playerZ < oPlayerZ) {
+            z = 1.0d;
+        } else if (playerZ > oPlayerZ) {
+            z = -1.0d;
+        }
+        return new Vector(x, y, z);
+    }
+
+    public static void handleForcefield(Player player, PlotPlayer plotPlayer, Plot plot) {
+        if (Flags.FORCEFIELD.isTrue(plot)) {
+            UUID uuid = plotPlayer.getUUID();
+            if (plot.isAdded(uuid)) {
+                Set<PlotPlayer> players = getNearbyPlayers(player, plot);
+                for (PlotPlayer oPlayer : players) {
+                    if (!Permissions
+                        .hasPermission(oPlayer, Captions.PERMISSION_ADMIN_ENTRY_FORCEFIELD)) {
+                        ((BukkitPlayer) oPlayer).player
+                            .setVelocity(calculateVelocity(plotPlayer, oPlayer));
+                    }
+                }
+            } else {
+                PlotPlayer oPlayer = hasNearbyPermitted(player, plot);
+                if (oPlayer == null) {
+                    return;
+                }
+                if (!Permissions
+                    .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_ENTRY_FORCEFIELD)) {
+                    player.setVelocity(calculateVelocity(oPlayer, plotPlayer));
+                }
+            }
+        }
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/listeners/PlotPlusListener.java

@@ -0,0 +1,189 @@
+package com.github.intellectualsites.plotsquared.bukkit.listeners;
+
+import com.github.intellectualsites.plotsquared.bukkit.events.PlayerEnterPlotEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlayerLeavePlotEvent;
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitUtil;
+import com.github.intellectualsites.plotsquared.plot.flag.Flags;
+import com.github.intellectualsites.plotsquared.plot.flag.IntervalFlag;
+import com.github.intellectualsites.plotsquared.plot.listener.PlotListener;
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.block.Block;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockDamageEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityPickupItemEvent;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.UUID;
+
+@SuppressWarnings("unused") public class PlotPlusListener extends PlotListener implements Listener {
+
+    private static final HashMap<UUID, Interval> feedRunnable = new HashMap<>();
+    private static final HashMap<UUID, Interval> healRunnable = new HashMap<>();
+
+    public static void startRunnable(JavaPlugin plugin) {
+        plugin.getServer().getScheduler().scheduleSyncRepeatingTask(plugin, () -> {
+            if (!healRunnable.isEmpty()) {
+                for (Iterator<Entry<UUID, Interval>> iterator =
+                     healRunnable.entrySet().iterator(); iterator.hasNext(); ) {
+                    Entry<UUID, Interval> entry = iterator.next();
+                    Interval value = entry.getValue();
+                    ++value.count;
+                    if (value.count == value.interval) {
+                        value.count = 0;
+                        Player player = Bukkit.getPlayer(entry.getKey());
+                        if (player == null) {
+                            iterator.remove();
+                            continue;
+                        }
+                        double level = player.getHealth();
+                        if (level != value.max) {
+                            player.setHealth(Math.min(level + value.amount, value.max));
+                        }
+                    }
+                }
+            }
+            if (!feedRunnable.isEmpty()) {
+                for (Iterator<Entry<UUID, Interval>> iterator =
+                     feedRunnable.entrySet().iterator(); iterator.hasNext(); ) {
+                    Entry<UUID, Interval> entry = iterator.next();
+                    Interval value = entry.getValue();
+                    ++value.count;
+                    if (value.count == value.interval) {
+                        value.count = 0;
+                        Player player = Bukkit.getPlayer(entry.getKey());
+                        if (player == null) {
+                            iterator.remove();
+                            continue;
+                        }
+                        int level = player.getFoodLevel();
+                        if (level != value.max) {
+                            player.setFoodLevel(Math.min(level + value.amount, value.max));
+                        }
+                    }
+                }
+            }
+        }, 0L, 20L);
+    }
+
+    @EventHandler(priority = EventPriority.HIGH) public void onInteract(BlockDamageEvent event) {
+        Player player = event.getPlayer();
+        if (player.getGameMode() != GameMode.SURVIVAL) {
+            return;
+        }
+        Plot plot = BukkitUtil.getLocation(player).getOwnedPlot();
+        if (plot == null) {
+            return;
+        }
+        if (Flags.INSTABREAK.isTrue(plot)) {
+            Block block = event.getBlock();
+            BlockBreakEvent call = new BlockBreakEvent(block, player);
+            Bukkit.getServer().getPluginManager().callEvent(call);
+            if (!call.isCancelled()) {
+                event.getBlock().breakNaturally();
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGH) public void onDamage(EntityDamageEvent event) {
+        if (event.getEntityType() != EntityType.PLAYER) {
+            return;
+        }
+        Plot plot = BukkitUtil.getLocation(event.getEntity()).getOwnedPlot();
+        if (plot == null) {
+            return;
+        }
+        if (Flags.INVINCIBLE.isTrue(plot)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler public void onItemDrop(PlayerDropItemEvent event) {
+        Player player = event.getPlayer();
+        PlotPlayer pp = BukkitUtil.getPlayer(player);
+        Plot plot = BukkitUtil.getLocation(player).getOwnedPlot();
+        if (plot == null) {
+            return;
+        }
+        UUID uuid = pp.getUUID();
+        if (!plot.isAdded(uuid)) {
+            if (Flags.ITEM_DROP.isFalse(plot)) {
+                event.setCancelled(true);
+            }
+        }
+    }
+
+    @EventHandler public void onPlotEnter(PlayerEnterPlotEvent event) {
+        Player player = event.getPlayer();
+        Plot plot = event.getPlot();
+        Optional<IntervalFlag.Interval> feed = plot.getFlag(Flags.FEED);
+        feed.ifPresent(value -> feedRunnable
+            .put(player.getUniqueId(), new Interval(value.getVal1(), value.getVal2(), 20)));
+        Optional<IntervalFlag.Interval> heal = plot.getFlag(Flags.HEAL);
+        heal.ifPresent(value -> healRunnable
+            .put(player.getUniqueId(), new Interval(value.getVal1(), value.getVal2(), 20)));
+    }
+
+    @EventHandler public void onPlayerQuit(PlayerQuitEvent event) {
+        Player player = event.getPlayer();
+        feedRunnable.remove(player.getUniqueId());
+        healRunnable.remove(player.getUniqueId());
+    }
+
+    @EventHandler public void onPlotLeave(PlayerLeavePlotEvent event) {
+        Player leaver = event.getPlayer();
+        Plot plot = event.getPlot();
+        if (!plot.hasOwner()) {
+            return;
+        }
+        BukkitUtil.getPlayer(leaver);
+        feedRunnable.remove(leaver.getUniqueId());
+        healRunnable.remove(leaver.getUniqueId());
+    }
+
+    @EventHandler public void onItemPickup(EntityPickupItemEvent event) {
+        LivingEntity ent = event.getEntity();
+        if (ent instanceof Player) {
+            Player player = (Player) ent;
+            PlotPlayer pp = BukkitUtil.getPlayer(player);
+            Plot plot = BukkitUtil.getLocation(player).getOwnedPlot();
+            if (plot == null) {
+                return;
+            }
+            UUID uuid = pp.getUUID();
+            if (!plot.isAdded(uuid) && Flags.DROP_PROTECTION.isTrue(plot)) {
+                event.setCancelled(true);
+            }
+        }
+    }
+
+    private static class Interval {
+
+        final int interval;
+        final int amount;
+        final int max;
+        int count = 0;
+
+        Interval(int interval, int amount, int max) {
+            this.interval = interval;
+            this.amount = amount;
+            this.max = max;
+        }
+    }
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/listeners/SingleWorldListener.java

@@ -0,0 +1,100 @@
+package com.github.intellectualsites.plotsquared.bukkit.listeners;
+
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.object.worlds.PlotAreaManager;
+import com.github.intellectualsites.plotsquared.plot.object.worlds.SinglePlotAreaManager;
+import com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.ChunkEvent;
+import org.bukkit.event.world.ChunkLoadEvent;
+import org.bukkit.plugin.Plugin;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.getRefClass;
+
+@SuppressWarnings("unused") public class SingleWorldListener implements Listener {
+
+    private Method methodGetHandleChunk;
+    private Field mustSave;
+
+    public SingleWorldListener(Plugin plugin) throws Exception {
+        ReflectionUtils.RefClass classChunk = getRefClass("{nms}.Chunk");
+        ReflectionUtils.RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
+        this.methodGetHandleChunk = classCraftChunk.getMethod("getHandle").getRealMethod();
+        try {
+            this.mustSave = classChunk.getField("mustSave").getRealField();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        Bukkit.getPluginManager().registerEvents(this, plugin);
+    }
+
+    public void markChunkAsClean(Chunk chunk) {
+        try {
+            Object nmsChunk = methodGetHandleChunk.invoke(chunk);
+            if (mustSave != null) {
+                this.mustSave.set(nmsChunk, false);
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void handle(ChunkEvent event) {
+        World world = event.getWorld();
+        String name = world.getName();
+        PlotAreaManager man = PlotSquared.get().getPlotAreaManager();
+        if (!(man instanceof SinglePlotAreaManager)) {
+            return;
+        }
+        if (!isPlotId(name)) {
+            return;
+        }
+
+        markChunkAsClean(event.getChunk());
+    }
+
+    //    @EventHandler
+    //    public void onPopulate(ChunkPopulateEvent event) {
+    //        handle(event);
+    //    }
+
+    @EventHandler(priority = EventPriority.LOWEST) public void onChunkLoad(ChunkLoadEvent event) {
+        handle(event);
+    }
+
+    private boolean isPlotId(String worldName) {
+        int len = worldName.length();
+        int separator = 0;
+        for (int i = 0; i < len; i++) {
+            switch (worldName.charAt(i)) {
+                case ',':
+                case ';':
+                    separator++;
+                    break;
+                case '-':
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                    break;
+                default:
+                    return false;
+            }
+        }
+        return separator == 1;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/listeners/WorldEvents.java

@@ -0,0 +1,37 @@
+package com.github.intellectualsites.plotsquared.bukkit.listeners;
+
+import com.github.intellectualsites.plotsquared.bukkit.generator.BukkitPlotGenerator;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.generator.GeneratorWrapper;
+import com.github.intellectualsites.plotsquared.plot.object.worlds.PlotAreaManager;
+import com.github.intellectualsites.plotsquared.plot.object.worlds.SinglePlotAreaManager;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.WorldInitEvent;
+import org.bukkit.generator.ChunkGenerator;
+
+@SuppressWarnings("unused")
+public class WorldEvents implements Listener {
+
+  @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+  public void onWorldInit(WorldInitEvent event) {
+    World world = event.getWorld();
+    String name = world.getName();
+    PlotAreaManager manager = PlotSquared.get().getPlotAreaManager();
+    if (manager instanceof SinglePlotAreaManager) {
+      SinglePlotAreaManager single = (SinglePlotAreaManager) manager;
+      if (single.isWorld(name)) {
+        world.setKeepSpawnInMemory(false);
+        return;
+      }
+    }
+    ChunkGenerator gen = world.getGenerator();
+    if (gen instanceof GeneratorWrapper) {
+      PlotSquared.get().loadWorld(name, (GeneratorWrapper<?>) gen);
+    } else {
+      PlotSquared.get().loadWorld(name, new BukkitPlotGenerator(name, gen));
+    }
+  }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/object/BukkitBlockUtil.java

@@ -0,0 +1,31 @@
+package com.github.intellectualsites.plotsquared.bukkit.object;
+
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.world.block.BlockState;
+import com.sk89q.worldedit.world.item.ItemType;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+
+import java.util.function.Supplier;
+
+public class BukkitBlockUtil {
+    public static Supplier<ItemType> supplyItem(Block block) {
+        return new Supplier<ItemType>() {
+            @Override public ItemType get() {
+                return BukkitAdapter.asItemType(block.getType());
+            }
+        };
+    }
+
+    public static Supplier<ItemType> supplyItem(Material type) {
+        return () -> BukkitAdapter.asItemType(type);
+    }
+
+    public static BlockState get(Block block) {
+        return get(block.getType());
+    }
+
+    public static BlockState get(Material material) {
+        return BukkitAdapter.asBlockType(material).getDefaultState();
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/object/BukkitOfflinePlayer.java

@@ -1,40 +1,38 @@
-package com.plotsquared.bukkit.object;
+package com.github.intellectualsites.plotsquared.bukkit.object;
+
+import com.github.intellectualsites.plotsquared.plot.object.OfflinePlotPlayer;
+import org.bukkit.OfflinePlayer;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.UUID;
 
-import org.bukkit.OfflinePlayer;
-
-import com.intellectualcrafters.plot.object.OfflinePlotPlayer;
-
 public class BukkitOfflinePlayer implements OfflinePlotPlayer {
-    
+
     public final OfflinePlayer player;
 
     /**
-     * Please do not use this method. Instead use BukkitUtil.getPlayer(Player), as it caches player objects.
+     * Please do not use this method. Instead use BukkitUtil.getPlayer(Player),
+     * as it caches player objects.
+     *
      * @param player
      */
-    public BukkitOfflinePlayer(final OfflinePlayer player) {
+    public BukkitOfflinePlayer(OfflinePlayer player) {
         this.player = player;
     }
-    
-    @Override
-    public UUID getUUID() {
+
+    @NotNull @Override public UUID getUUID() {
         return this.player.getUniqueId();
     }
-    
-    @Override
-    public long getLastPlayed() {
+
+    @Override public long getLastPlayed() {
         return this.player.getLastPlayed();
     }
-    
-    @Override
-    public boolean isOnline() {
+
+    @Override public boolean isOnline() {
         return this.player.isOnline();
     }
-    
-    @Override
-    public String getName() {
+
+    @Override public String getName() {
         return this.player.getName();
     }
 }

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/object/BukkitPlayer.java

@@ -0,0 +1,314 @@
+package com.github.intellectualsites.plotsquared.bukkit.object;
+
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitEventUtil;
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitUtil;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.config.Captions;
+import com.github.intellectualsites.plotsquared.plot.object.Location;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.TeleportCause;
+import com.github.intellectualsites.plotsquared.plot.util.EconHandler;
+import com.github.intellectualsites.plotsquared.plot.util.EventUtil;
+import com.github.intellectualsites.plotsquared.plot.util.MathMan;
+import com.github.intellectualsites.plotsquared.plot.util.PlotWeather;
+import com.github.intellectualsites.plotsquared.plot.util.StringMan;
+import com.github.intellectualsites.plotsquared.plot.util.UUIDHandler;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.extension.platform.Actor;
+import com.sk89q.worldedit.world.item.ItemType;
+import com.sk89q.worldedit.world.item.ItemTypes;
+import io.papermc.lib.PaperLib;
+import org.bukkit.GameMode;
+import org.bukkit.Sound;
+import org.bukkit.WeatherType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.EventException;
+import org.bukkit.event.player.PlayerTeleportEvent;
+import org.bukkit.permissions.PermissionAttachmentInfo;
+import org.bukkit.plugin.RegisteredListener;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Set;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+import static com.sk89q.worldedit.world.gamemode.GameModes.ADVENTURE;
+import static com.sk89q.worldedit.world.gamemode.GameModes.CREATIVE;
+import static com.sk89q.worldedit.world.gamemode.GameModes.SPECTATOR;
+import static com.sk89q.worldedit.world.gamemode.GameModes.SURVIVAL;
+
+public class BukkitPlayer extends PlotPlayer {
+
+    private static boolean CHECK_EFFECTIVE = true;
+    public final Player player;
+    private boolean offline;
+    private UUID uuid;
+    private String name;
+
+    /**
+     * <p>Please do not use this method. Instead use
+     * BukkitUtil.getPlayer(Player), as it caches player objects.</p>
+     *
+     * @param player Bukkit player instance
+     */
+    public BukkitPlayer(@NotNull final Player player) {
+        this.player = player;
+        super.populatePersistentMetaMap();
+    }
+
+    public BukkitPlayer(@NotNull final Player player, final boolean offline) {
+        this.player = player;
+        this.offline = offline;
+        super.populatePersistentMetaMap();
+    }
+
+    @Override public Actor toActor() {
+        return BukkitAdapter.adapt(player);
+    }
+
+    @NotNull @Override public Location getLocation() {
+        final Location location = super.getLocation();
+        return location == null ? BukkitUtil.getLocation(this.player) : location;
+    }
+
+    @NotNull @Override public UUID getUUID() {
+        if (this.uuid == null) {
+            this.uuid = UUIDHandler.getUUID(this);
+        }
+        return this.uuid;
+    }
+
+    @Override public long getLastPlayed() {
+        return this.player.getLastPlayed();
+    }
+
+    @Override public boolean canTeleport(@NotNull final Location location) {
+        final org.bukkit.Location to = BukkitUtil.getLocation(location);
+        final org.bukkit.Location from = player.getLocation();
+        PlayerTeleportEvent event = new PlayerTeleportEvent(player, from, to);
+        callEvent(event);
+        if (event.isCancelled() || !event.getTo().equals(to)) {
+            return false;
+        }
+        event = new PlayerTeleportEvent(player, to, from);
+        callEvent(event);
+        return true;
+    }
+
+    @Override
+    public void sendTitle(String title, String subtitle, int fadeIn, int stay, int fadeOut) {
+        player.sendTitle(title, subtitle, fadeIn, stay, fadeOut);
+    }
+
+    private void callEvent(@NotNull final Event event) {
+        final RegisteredListener[] listeners = event.getHandlers().getRegisteredListeners();
+        for (final RegisteredListener listener : listeners) {
+            if (listener.getPlugin().getName().equals(PlotSquared.imp().getPluginName())) {
+                continue;
+            }
+            try {
+                listener.callEvent(event);
+            } catch (final EventException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override public boolean hasPermission(final String permission) {
+        if (this.offline && EconHandler.manager != null) {
+            return EconHandler.manager.hasPermission(getName(), permission);
+        }
+        return this.player.hasPermission(permission);
+    }
+
+    @Override public int hasPermissionRange(final String stub, final int range) {
+        if (hasPermission(Captions.PERMISSION_ADMIN.getTranslated())) {
+            return Integer.MAX_VALUE;
+        }
+        final String[] nodes = stub.split("\\.");
+        final StringBuilder n = new StringBuilder();
+        for (int i = 0; i < (nodes.length - 1); i++) {
+            n.append(nodes[i]).append(".");
+            if (!stub.equals(n + Captions.PERMISSION_STAR.getTranslated())) {
+                if (hasPermission(n + Captions.PERMISSION_STAR.getTranslated())) {
+                    return Integer.MAX_VALUE;
+                }
+            }
+        }
+        if (hasPermission(stub + ".*")) {
+            return Integer.MAX_VALUE;
+        }
+        int max = 0;
+        if (CHECK_EFFECTIVE) {
+            boolean hasAny = false;
+            String stubPlus = stub + ".";
+        final Set<PermissionAttachmentInfo> effective = player.getEffectivePermissions();
+            if (!effective.isEmpty()) {
+                for (PermissionAttachmentInfo attach : effective) {
+                    String permStr = attach.getPermission();
+                    if (permStr.startsWith(stubPlus)) {
+                        hasAny = true;
+                        String end = permStr.substring(stubPlus.length());
+                        if (MathMan.isInteger(end)) {
+                            int val = Integer.parseInt(end);
+                            if (val > range) {
+                                return val;
+                            }
+                            if (val > max) {
+                                max = val;
+                            }
+                        }
+                    }
+                }
+                if (hasAny) {
+                    return max;
+                }
+                // Workaround
+                for (PermissionAttachmentInfo attach : effective) {
+                    String permStr = attach.getPermission();
+                    if (permStr.startsWith("plots.") && !permStr.equals("plots.use")) {
+                        return max;
+                    }
+                }
+                CHECK_EFFECTIVE = false;
+            }
+        }
+        for (int i = range; i > 0; i--) {
+            if (hasPermission(stub + "." + i)) {
+                return i;
+            }
+        }
+        return max;
+    }
+
+    @Override public boolean isPermissionSet(final String permission) {
+        return this.player.isPermissionSet(permission);
+    }
+
+    @Override public void sendMessage(final String message) {
+        if (!StringMan.isEqual(this.getMeta("lastMessage"), message) || (
+            System.currentTimeMillis() - this.<Long>getMeta("lastMessageTime") > 5000)) {
+            setMeta("lastMessage", message);
+            setMeta("lastMessageTime", System.currentTimeMillis());
+            this.player.sendMessage(message);
+        }
+    }
+
+    @Override public void teleport(@NotNull final Location location, @NotNull final TeleportCause cause) {
+        if (Math.abs(location.getX()) >= 30000000 || Math.abs(location.getZ()) >= 30000000) {
+            return;
+        }
+        final org.bukkit.Location bukkitLocation = new org.bukkit.Location(BukkitUtil.getWorld(location.getWorld()), location.getX() + 0.5,
+            location.getY(), location.getZ() + 0.5, location.getYaw(), location.getPitch());
+        PaperLib.teleportAsync(player, bukkitLocation, ((BukkitEventUtil) EventUtil.manager).getTeleportCause(cause));
+    }
+
+    @Override public String getName() {
+        if (this.name == null) {
+            this.name = this.player.getName();
+        }
+        return this.name;
+    }
+
+    @Override public boolean isOnline() {
+        return !this.offline && this.player.isOnline();
+    }
+
+    @Override public void setCompassTarget(Location location) {
+        this.player.setCompassTarget(
+            new org.bukkit.Location(BukkitUtil.getWorld(location.getWorld()), location.getX(),
+                location.getY(), location.getZ()));
+    }
+
+    @Override public Location getLocationFull() {
+        return BukkitUtil.getLocationFull(this.player);
+    }
+
+    @Override public void setWeather(@NotNull final PlotWeather weather) {
+        switch (weather) {
+            case CLEAR:
+                this.player.setPlayerWeather(WeatherType.CLEAR);
+                break;
+            case RAIN:
+                this.player.setPlayerWeather(WeatherType.DOWNFALL);
+                break;
+            case RESET:
+            default:
+                this.player.resetPlayerWeather();
+                break;
+        }
+    }
+
+    @NotNull @Override public com.sk89q.worldedit.world.gamemode.GameMode getGameMode() {
+        switch (this.player.getGameMode()) {
+            case ADVENTURE:
+                return ADVENTURE;
+            case CREATIVE:
+                return CREATIVE;
+            case SPECTATOR:
+                return SPECTATOR;
+            case SURVIVAL:
+            default:
+                return SURVIVAL;
+        }
+    }
+
+    @Override public void setGameMode(@NotNull final com.sk89q.worldedit.world.gamemode.GameMode gameMode) {
+        if (ADVENTURE.equals(gameMode)) {
+            this.player.setGameMode(GameMode.ADVENTURE);
+        } else if (CREATIVE.equals(gameMode)) {
+            this.player.setGameMode(GameMode.CREATIVE);
+        } else if (SPECTATOR.equals(gameMode)) {
+            this.player.setGameMode(GameMode.SPECTATOR);
+        } else {
+            this.player.setGameMode(GameMode.SURVIVAL);
+        }
+    }
+
+    @Override public void setTime(final long time) {
+        if (time != Long.MAX_VALUE) {
+            this.player.setPlayerTime(time, false);
+        } else {
+            this.player.resetPlayerTime();
+        }
+    }
+
+    @Override public boolean getFlight() {
+        return player.getAllowFlight();
+    }
+
+    @Override public void setFlight(boolean fly) {
+        this.player.setAllowFlight(fly);
+    }
+
+    @Override public void playMusic(@NotNull final Location location, @NotNull final ItemType id) {
+        if (id == ItemTypes.AIR) {
+            // Let's just stop all the discs because why not?
+            for (final Sound sound : Arrays.stream(Sound.values())
+                .filter(sound -> sound.name().contains("DISC")).collect(Collectors.toList())) {
+                player.stopSound(sound);
+            }
+            // this.player.playEffect(BukkitUtil.getLocation(location), Effect.RECORD_PLAY, Material.AIR);
+        } else {
+            // this.player.playEffect(BukkitUtil.getLocation(location), Effect.RECORD_PLAY, id.to(Material.class));
+            this.player.playSound(BukkitUtil.getLocation(location),
+                Sound.valueOf(BukkitAdapter.adapt(id).name()), Float.MAX_VALUE, 1f);
+        }
+    }
+
+    @Override public void kick(final String message) {
+        this.player.kickPlayer(message);
+    }
+
+    @Override public void stopSpectating() {
+        if (getGameMode() == SPECTATOR) {
+            this.player.setSpectatorTarget(null);
+        }
+    }
+
+    @Override public boolean isBanned() {
+        return this.player.isBanned();
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/object/entity/AgeableStats.java

@@ -0,0 +1,8 @@
+package com.github.intellectualsites.plotsquared.bukkit.object.entity;
+
+class AgeableStats {
+
+    int age;
+    boolean locked;
+    boolean adult;
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/object/entity/ArmorStandStats.java

@@ -0,0 +1,15 @@
+package com.github.intellectualsites.plotsquared.bukkit.object.entity;
+
+class ArmorStandStats {
+
+    final float[] head = new float[3];
+    final float[] body = new float[3];
+    final float[] leftLeg = new float[3];
+    final float[] rightLeg = new float[3];
+    final float[] leftArm = new float[3];
+    final float[] rightArm = new float[3];
+    boolean arms;
+    boolean noPlate;
+    boolean invisible;
+    boolean small;
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/object/entity/EntityBaseStats.java

@@ -0,0 +1,12 @@
+package com.github.intellectualsites.plotsquared.bukkit.object.entity;
+
+class EntityBaseStats {
+
+    EntityWrapper passenger;
+    float fall;
+    short fire;
+    int age;
+    double vZ;
+    double vY;
+    double vX;
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/object/entity/EntityWrapper.java

@@ -0,0 +1,40 @@
+package com.github.intellectualsites.plotsquared.bukkit.object.entity;
+
+import lombok.Getter;
+import lombok.NonNull;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+
+@Getter public abstract class EntityWrapper {
+
+    protected final float yaw;
+    protected final float pitch;
+    private final Entity entity;
+    private final EntityType type;
+    public double x;
+    public double y;
+    public double z;
+
+    EntityWrapper(@NonNull final Entity entity) {
+        this.entity = entity;
+        this.type = entity.getType();
+
+        final Location location = entity.getLocation();
+        this.x = location.getX();
+        this.y = location.getY();
+        this.z = location.getZ();
+        this.yaw = location.getYaw();
+        this.pitch = location.getPitch();
+    }
+
+    @SuppressWarnings("deprecation") @Override public String toString() {
+        return String.format("[%s, x=%s, y=%s, z=%s]", type.getName(), x, y, z);
+    }
+
+    public abstract Entity spawn(World world, int xOffset, int zOffset);
+
+    public abstract void saveEntity();
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/object/entity/HorseStats.java

@@ -0,0 +1,12 @@
+package com.github.intellectualsites.plotsquared.bukkit.object.entity;
+
+import org.bukkit.entity.Horse;
+
+class HorseStats {
+
+    double jump;
+    boolean chest;
+    Horse.Variant variant;
+    Horse.Color color;
+    Horse.Style style;
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/object/entity/LivingEntityStats.java

@@ -0,0 +1,28 @@
+package com.github.intellectualsites.plotsquared.bukkit.object.entity;
+
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffect;
+
+import java.util.Collection;
+
+class LivingEntityStats {
+
+    boolean loot;
+    String name;
+    boolean visible;
+    float health;
+    short air;
+    boolean persistent;
+    boolean leashed;
+    short leashX;
+    short leashY;
+    short leashZ;
+    boolean equipped;
+    ItemStack mainHand;
+    ItemStack helmet;
+    ItemStack boots;
+    ItemStack leggings;
+    ItemStack chestplate;
+    Collection<PotionEffect> potions;
+    ItemStack offHand;
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/object/entity/TameableStats.java

@@ -0,0 +1,9 @@
+package com.github.intellectualsites.plotsquared.bukkit.object.entity;
+
+import org.bukkit.entity.AnimalTamer;
+
+class TameableStats {
+
+    AnimalTamer owner;
+    boolean tamed;
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/object/entity/TeleportEntityWrapper.java

@@ -0,0 +1,93 @@
+package com.github.intellectualsites.plotsquared.bukkit.object.entity;
+
+import com.github.intellectualsites.plotsquared.bukkit.BukkitMain;
+import org.bukkit.Chunk;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+import org.bukkit.metadata.FixedMetadataValue;
+
+public class TeleportEntityWrapper extends EntityWrapper {
+
+    private Location oldLocation;
+    private boolean gravityOld;
+    private boolean invulnerableOld;
+    private int fireTicksOld;
+    private int livingTicksOld;
+
+    public TeleportEntityWrapper(final Entity entity) {
+        super(entity);
+    }
+
+    @Override public Entity spawn(final World world, final int xOffset, final int zOffset) {
+        if (!getEntity().getLocation().getChunk().equals(oldLocation.getChunk())) {
+            final Location oldLocation = this.oldLocation.clone();
+            oldLocation.add(xOffset, 0, xOffset);
+            getEntity().teleport(oldLocation);
+            getEntity().setGravity(gravityOld);
+            getEntity().setInvulnerable(invulnerableOld);
+            getEntity().setFireTicks(fireTicksOld);
+            getEntity().setTicksLived(livingTicksOld);
+            getEntity().removeMetadata("ps-tmp-teleport", BukkitMain.getPlugin(BukkitMain.class));
+        }
+        return getEntity();
+    }
+
+    @Override public void saveEntity() {
+        if (getEntity().hasMetadata("ps-tmp-teleport")) {
+            this.oldLocation = (Location) this.getEntity().getMetadata("ps-tmp-teleport").get(0);
+        } else {
+            this.oldLocation = this.getEntity().getLocation();
+        }
+
+        // To account for offsets in the chunk manager
+        this.oldLocation = oldLocation.clone();
+        this.oldLocation.setX(this.x);
+        this.oldLocation.setY(this.y);
+        this.oldLocation.setZ(this.z);
+
+        this.gravityOld = this.getEntity().hasGravity();
+        this.getEntity().setGravity(false);
+        this.invulnerableOld = this.getEntity().isInvulnerable();
+        this.getEntity().setInvulnerable(true);
+        this.fireTicksOld = this.getEntity().getFireTicks();
+        this.livingTicksOld = this.getEntity().getTicksLived();
+        this.getEntity().setMetadata("ps-tmp-teleport",
+            new FixedMetadataValue(BukkitMain.getPlugin(BukkitMain.class), oldLocation));
+        final Chunk newChunk = getNewChunk();
+        this.getEntity().teleport(
+            new Location(newChunk.getWorld(), newChunk.getX() << 4, 5000, newChunk.getZ() << 4));
+    }
+
+    private Chunk getNewChunk() {
+        final Chunk oldChunk = oldLocation.getChunk();
+        Chunk chunk = null;
+
+        for (Chunk lChunk : oldChunk.getWorld().getLoadedChunks()) {
+            if (!lChunk.equals(oldChunk) && lChunk.isLoaded()) {
+                chunk = lChunk;
+                break;
+            }
+        }
+        if (chunk == null) {
+            for (int dx = 1; dx < Integer.MAX_VALUE; dx++) {
+                for (int dz = 0; dz < Integer.MAX_VALUE; dz++) {
+                    if ((chunk = getChunkRelative(oldChunk, dx, dz)).isLoaded()) {
+                        break;
+                    } else if ((chunk = getChunkRelative(oldChunk, -dx, dz)).isLoaded()) {
+                        break;
+                    } else if ((chunk = getChunkRelative(oldChunk, dx, -dz)).isLoaded()) {
+                        break;
+                    } else if ((chunk = getChunkRelative(oldChunk, -dx, -dz)).isLoaded()) {
+                        break;
+                    }
+                }
+            }
+        }
+        return chunk;
+    }
+
+    private Chunk getChunkRelative(final Chunk chunk, final int dx, final int dz) {
+        return chunk.getWorld().getChunkAt(chunk.getX() + dx, chunk.getZ() + dz);
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/object/schematic/StateWrapper.java

@@ -0,0 +1,265 @@
+package com.github.intellectualsites.plotsquared.bukkit.object.schematic;
+
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitUtil;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.config.Captions;
+import com.sk89q.jnbt.ByteTag;
+import com.sk89q.jnbt.CompoundTag;
+import com.sk89q.jnbt.ListTag;
+import com.sk89q.jnbt.ShortTag;
+import com.sk89q.jnbt.StringTag;
+import com.sk89q.jnbt.Tag;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.block.Container;
+import org.bukkit.block.Sign;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class StateWrapper {
+
+    public org.bukkit.block.BlockState state = null;
+    public CompoundTag tag = null;
+
+    public StateWrapper(org.bukkit.block.BlockState state) {
+        this.state = state;
+    }
+
+    public StateWrapper(CompoundTag tag) {
+        this.tag = tag;
+    }
+
+    public static String jsonToColourCode(String str) {
+        str = str.replace("{\"extra\":", "").replace("],\"text\":\"\"}", "]")
+            .replace("[{\"color\":\"black\",\"text\":\"", "&0")
+            .replace("[{\"color\":\"dark_blue\",\"text\":\"", "&1")
+            .replace("[{\"color\":\"dark_green\",\"text\":\"", "&2")
+            .replace("[{\"color\":\"dark_aqua\",\"text\":\"", "&3")
+            .replace("[{\"color\":\"dark_red\",\"text\":\"", "&4")
+            .replace("[{\"color\":\"dark_purple\",\"text\":\"", "&5")
+            .replace("[{\"color\":\"gold\",\"text\":\"", "&6")
+            .replace("[{\"color\":\"gray\",\"text\":\"", "&7")
+            .replace("[{\"color\":\"dark_gray\",\"text\":\"", "&8")
+            .replace("[{\"color\":\"blue\",\"text\":\"", "&9")
+            .replace("[{\"color\":\"green\",\"text\":\"", "&a")
+            .replace("[{\"color\":\"aqua\",\"text\":\"", "&b")
+            .replace("[{\"color\":\"red\",\"text\":\"", "&c")
+            .replace("[{\"color\":\"light_purple\",\"text\":\"", "&d")
+            .replace("[{\"color\":\"yellow\",\"text\":\"", "&e")
+            .replace("[{\"color\":\"white\",\"text\":\"", "&f")
+            .replace("[{\"obfuscated\":true,\"text\":\"", "&k")
+            .replace("[{\"bold\":true,\"text\":\"", "&l")
+            .replace("[{\"strikethrough\":true,\"text\":\"", "&m")
+            .replace("[{\"underlined\":true,\"text\":\"", "&n")
+            .replace("[{\"italic\":true,\"text\":\"", "&o").replace("[{\"color\":\"black\",", "&0")
+            .replace("[{\"color\":\"dark_blue\",", "&1")
+            .replace("[{\"color\":\"dark_green\",", "&2")
+            .replace("[{\"color\":\"dark_aqua\",", "&3").replace("[{\"color\":\"dark_red\",", "&4")
+            .replace("[{\"color\":\"dark_purple\",", "&5").replace("[{\"color\":\"gold\",", "&6")
+            .replace("[{\"color\":\"gray\",", "&7").replace("[{\"color\":\"dark_gray\",", "&8")
+            .replace("[{\"color\":\"blue\",", "&9").replace("[{\"color\":\"green\",", "&a")
+            .replace("[{\"color\":\"aqua\",", "&b").replace("[{\"color\":\"red\",", "&c")
+            .replace("[{\"color\":\"light_purple\",", "&d").replace("[{\"color\":\"yellow\",", "&e")
+            .replace("[{\"color\":\"white\",", "&f").replace("[{\"obfuscated\":true,", "&k")
+            .replace("[{\"bold\":true,", "&l").replace("[{\"strikethrough\":true,", "&m")
+            .replace("[{\"underlined\":true,", "&n").replace("[{\"italic\":true,", "&o")
+            .replace("{\"color\":\"black\",\"text\":\"", "&0")
+            .replace("{\"color\":\"dark_blue\",\"text\":\"", "&1")
+            .replace("{\"color\":\"dark_green\",\"text\":\"", "&2")
+            .replace("{\"color\":\"dark_aqua\",\"text\":\"", "&3")
+            .replace("{\"color\":\"dark_red\",\"text\":\"", "&4")
+            .replace("{\"color\":\"dark_purple\",\"text\":\"", "&5")
+            .replace("{\"color\":\"gold\",\"text\":\"", "&6")
+            .replace("{\"color\":\"gray\",\"text\":\"", "&7")
+            .replace("{\"color\":\"dark_gray\",\"text\":\"", "&8")
+            .replace("{\"color\":\"blue\",\"text\":\"", "&9")
+            .replace("{\"color\":\"green\",\"text\":\"", "&a")
+            .replace("{\"color\":\"aqua\",\"text\":\"", "&b")
+            .replace("{\"color\":\"red\",\"text\":\"", "&c")
+            .replace("{\"color\":\"light_purple\",\"text\":\"", "&d")
+            .replace("{\"color\":\"yellow\",\"text\":\"", "&e")
+            .replace("{\"color\":\"white\",\"text\":\"", "&f")
+            .replace("{\"obfuscated\":true,\"text\":\"", "&k")
+            .replace("{\"bold\":true,\"text\":\"", "&l")
+            .replace("{\"strikethrough\":true,\"text\":\"", "&m")
+            .replace("{\"underlined\":true,\"text\":\"", "&n")
+            .replace("{\"italic\":true,\"text\":\"", "&o").replace("{\"color\":\"black\",", "&0")
+            .replace("{\"color\":\"dark_blue\",", "&1").replace("{\"color\":\"dark_green\",", "&2")
+            .replace("{\"color\":\"dark_aqua\",", "&3").replace("{\"color\":\"dark_red\",", "&4")
+            .replace("{\"color\":\"dark_purple\",", "&5").replace("{\"color\":\"gold\",", "&6")
+            .replace("{\"color\":\"gray\",", "&7").replace("{\"color\":\"dark_gray\",", "&8")
+            .replace("{\"color\":\"blue\",", "&9").replace("{\"color\":\"green\",", "&a")
+            .replace("{\"color\":\"aqua\",", "&b").replace("{\"color\":\"red\",", "&c")
+            .replace("{\"color\":\"light_purple\",", "&d").replace("{\"color\":\"yellow\",", "&e")
+            .replace("{\"color\":\"white\",", "&f").replace("{\"obfuscated\":true,", "&k")
+            .replace("{\"bold\":true,", "&l").replace("{\"strikethrough\":true,", "&m")
+            .replace("{\"underlined\":true,", "&n").replace("{\"italic\":true,", "&o")
+            .replace("\"color\":\"black\",\"text\":\"", "&0")
+            .replace("\"color\":\"dark_blue\",\"text\":\"", "&1")
+            .replace("\"color\":\"dark_green\",\"text\":\"", "&2")
+            .replace("\"color\":\"dark_aqua\",\"text\":\"", "&3")
+            .replace("\"color\":\"dark_red\",\"text\":\"", "&4")
+            .replace("\"color\":\"dark_purple\",\"text\":\"", "&5")
+            .replace("\"color\":\"gold\",\"text\":\"", "&6")
+            .replace("\"color\":\"gray\",\"text\":\"", "&7")
+            .replace("\"color\":\"dark_gray\",\"text\":\"", "&8")
+            .replace("\"color\":\"blue\",\"text\":\"", "&9")
+            .replace("\"color\":\"green\",\"text\":\"", "&a")
+            .replace("\"color\":\"aqua\",\"text\":\"", "&b")
+            .replace("\"color\":\"red\",\"text\":\"", "&c")
+            .replace("\"color\":\"light_purple\",\"text\":\"", "&d")
+            .replace("\"color\":\"yellow\",\"text\":\"", "&e")
+            .replace("\"color\":\"white\",\"text\":\"", "&f")
+            .replace("\"obfuscated\":true,\"text\":\"", "&k")
+            .replace("\"bold\":true,\"text\":\"", "&l")
+            .replace("\"strikethrough\":true,\"text\":\"", "&m")
+            .replace("\"underlined\":true,\"text\":\"", "&n")
+            .replace("\"italic\":true,\"text\":\"", "&o").replace("\"color\":\"black\",", "&0")
+            .replace("\"color\":\"dark_blue\",", "&1").replace("\"color\":\"dark_green\",", "&2")
+            .replace("\"color\":\"dark_aqua\",", "&3").replace("\"color\":\"dark_red\",", "&4")
+            .replace("\"color\":\"dark_purple\",", "&5").replace("\"color\":\"gold\",", "&6")
+            .replace("\"color\":\"gray\",", "&7").replace("\"color\":\"dark_gray\",", "&8")
+            .replace("\"color\":\"blue\",", "&9").replace("\"color\":\"green\",", "&a")
+            .replace("\"color\":\"aqua\",", "&b").replace("\"color\":\"red\",", "&c")
+            .replace("\"color\":\"light_purple\",", "&d").replace("\"color\":\"yellow\",", "&e")
+            .replace("\"color\":\"white\",", "&f").replace("\"obfuscated\":true,", "&k")
+            .replace("\"bold\":true,", "&l").replace("\"strikethrough\":true,", "&m")
+            .replace("\"underlined\":true,", "&n").replace("\"italic\":true,", "&o")
+            .replace("[{\"text\":\"", "&0").replace("{\"text\":\"", "&0").replace("\"},", "")
+            .replace("\"}]", "").replace("\"}", "");
+        for (Entry<String, String> entry : Captions.replacements.entrySet()) {
+            str = str.replace(entry.getKey(), entry.getValue());
+        }
+        return str;
+    }
+
+    public boolean restoreTag(String worldName, int x, int y, int z) {
+        if (this.tag == null) {
+            return false;
+        }
+        String tileid = this.tag.getString("id").toLowerCase();
+        if (tileid.startsWith("minecraft:")) {
+            tileid = tileid.replace("minecraft:", "");
+        }
+        World world = BukkitUtil.getWorld(worldName);
+        Block block = world.getBlockAt(x, y, z);
+        if (block == null) {
+            return false;
+        }
+        org.bukkit.block.BlockState state = block.getState();
+        switch (tileid) {
+            case "chest":
+            case "beacon":
+            case "brewingstand":
+            case "dispenser":
+            case "dropper":
+            case "furnace":
+            case "hopper":
+            case "shulkerbox":
+                List<Tag> itemsTag = this.tag.getListTag("Items").getValue();
+                int length = itemsTag.size();
+                String[] ids = new String[length];
+                byte[] amounts = new byte[length];
+                byte[] slots = new byte[length];
+                for (int i = 0; i < length; i++) {
+                    Tag itemTag = itemsTag.get(i);
+                    CompoundTag itemComp = (CompoundTag) itemTag;
+                    String id = itemComp.getString("id");
+                    if (id.startsWith("minecraft:")) {
+                        id = id.replace("minecraft:", "");
+                    }
+                    ids[i] = id;
+                    amounts[i] = itemComp.getByte("Count");
+                    slots[i] = itemComp.getByte("Slot");
+                }
+                if (state instanceof Container) {
+                    Container container = (Container) state;
+                    Inventory inv = container.getSnapshotInventory();
+                    for (int i = 0; i < ids.length; i++) {
+                        Material mat = Material.getMaterial(ids[i].toUpperCase());
+                        if (mat != null) {
+                            ItemStack item = new ItemStack(mat, (int) amounts[i]);
+                            inv.setItem(slots[i], item);
+                            PlotSquared.log(mat.name() + " " + slots[i]);
+                        }
+                    }
+                    PlotSquared.log(inv.getStorageContents());
+                    container.update(true, true);
+                    return true;
+                }
+                return false;
+            case "sign":
+                if (state instanceof Sign) {
+                    Sign sign = (Sign) state;
+                    sign.setLine(0, jsonToColourCode(tag.getString("Text1")));
+                    sign.setLine(1, jsonToColourCode(tag.getString("Text2")));
+                    sign.setLine(2, jsonToColourCode(tag.getString("Text3")));
+                    sign.setLine(3, jsonToColourCode(tag.getString("Text4")));
+                    state.update(true);
+                    return true;
+                }
+                return false;
+        }
+        return false;
+    }
+
+    public CompoundTag getTag() {
+        if (this.tag != null) {
+            return this.tag;
+        }
+        if (this.state instanceof InventoryHolder) {
+            InventoryHolder inv = (InventoryHolder) this.state;
+            ItemStack[] contents = inv.getInventory().getContents();
+            Map<String, Tag> values = new HashMap<>();
+            values.put("Items", new ListTag(CompoundTag.class, serializeInventory(contents)));
+            return new CompoundTag(values);
+        }
+        return null;
+    }
+
+    public String getId() {
+        return "Chest";
+    }
+
+    public List<CompoundTag> serializeInventory(ItemStack[] items) {
+        List<CompoundTag> tags = new ArrayList<>();
+        for (int i = 0; i < items.length; ++i) {
+            if (items[i] != null) {
+                Map<String, Tag> tagData = serializeItem(items[i]);
+                tagData.put("Slot", new ByteTag((byte) i));
+                tags.add(new CompoundTag(tagData));
+            }
+        }
+        return tags;
+    }
+
+    public Map<String, Tag> serializeItem(ItemStack item) {
+        Map<String, Tag> data = new HashMap<>();
+        data.put("id", new StringTag(item.getType().name()));
+        data.put("Damage", new ShortTag(item.getDurability()));
+        data.put("Count", new ByteTag((byte) item.getAmount()));
+        if (!item.getEnchantments().isEmpty()) {
+            List<CompoundTag> enchantmentList = new ArrayList<>();
+            for (Entry<Enchantment, Integer> entry : item.getEnchantments().entrySet()) {
+                Map<String, Tag> enchantment = new HashMap<>();
+                enchantment.put("id", new StringTag(entry.getKey().toString()));
+                enchantment.put("lvl", new ShortTag(entry.getValue().shortValue()));
+                enchantmentList.add(new CompoundTag(enchantment));
+            }
+            Map<String, Tag> auxData = new HashMap<>();
+            auxData.put("ench", new ListTag(CompoundTag.class, enchantmentList));
+            data.put("tag", new CompoundTag(auxData));
+        }
+        return data;
+    }
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitChatManager.java

@@ -0,0 +1,53 @@
+package com.github.intellectualsites.plotsquared.bukkit.util;
+
+import com.github.intellectualsites.plotsquared.bukkit.chat.FancyMessage;
+import com.github.intellectualsites.plotsquared.bukkit.object.BukkitPlayer;
+import com.github.intellectualsites.plotsquared.plot.config.Captions;
+import com.github.intellectualsites.plotsquared.plot.config.Settings;
+import com.github.intellectualsites.plotsquared.plot.object.ConsolePlayer;
+import com.github.intellectualsites.plotsquared.plot.object.PlotMessage;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.util.ChatManager;
+import org.bukkit.ChatColor;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class BukkitChatManager extends ChatManager<FancyMessage> {
+
+    @Override public FancyMessage builder() {
+        return new FancyMessage("");
+    }
+
+    @Override public void color(PlotMessage message, String color) {
+        message.$(this).color(ChatColor.getByChar(Captions.color(color).substring(1)));
+    }
+
+    @Override public void tooltip(PlotMessage message, PlotMessage... tooltips) {
+        List<FancyMessage> lines =
+            Arrays.stream(tooltips).map(tooltip -> tooltip.$(this)).collect(Collectors.toList());
+        message.$(this).formattedTooltip(lines);
+    }
+
+    @Override public void command(PlotMessage message, String command) {
+        message.$(this).command(command);
+    }
+
+    @Override public void text(PlotMessage message, String text) {
+        message.$(this).then(ChatColor.stripColor(text));
+    }
+
+    @Override public void send(PlotMessage plotMessage, PlotPlayer player) {
+        if (player instanceof ConsolePlayer || !Settings.Chat.INTERACTIVE) {
+            player.sendMessage(plotMessage.$(this).toOldMessageFormat());
+        } else {
+            plotMessage.$(this).send(((BukkitPlayer) player).player);
+        }
+    }
+
+    @Override public void suggest(PlotMessage plotMessage, String command) {
+        plotMessage.$(this).suggest(command);
+    }
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitChunkManager.java

@@ -0,0 +1,701 @@
+package com.github.intellectualsites.plotsquared.bukkit.util;
+
+import com.github.intellectualsites.plotsquared.bukkit.object.entity.EntityWrapper;
+import com.github.intellectualsites.plotsquared.bukkit.object.entity.ReplicatingEntityWrapper;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.generator.AugmentedUtils;
+import com.github.intellectualsites.plotsquared.plot.listener.WEExtent;
+import com.github.intellectualsites.plotsquared.plot.object.Location;
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.object.PlotArea;
+import com.github.intellectualsites.plotsquared.plot.object.PlotLoc;
+import com.github.intellectualsites.plotsquared.plot.object.RunnableVal;
+import com.github.intellectualsites.plotsquared.plot.util.ChunkManager;
+import com.github.intellectualsites.plotsquared.plot.util.TaskManager;
+import com.github.intellectualsites.plotsquared.plot.util.block.GlobalBlockQueue;
+import com.github.intellectualsites.plotsquared.plot.util.block.LocalBlockQueue;
+import com.github.intellectualsites.plotsquared.plot.util.block.ScopedLocalBlockQueue;
+import com.github.intellectualsites.plotsquared.plot.util.world.RegionUtil;
+import com.sk89q.worldedit.bukkit.BukkitWorld;
+import com.sk89q.worldedit.math.BlockVector2;
+import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldedit.regions.CuboidRegion;
+import com.sk89q.worldedit.world.block.BaseBlock;
+import com.sk89q.worldedit.world.block.BlockTypes;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.entity.Animals;
+import org.bukkit.entity.Creature;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+public class BukkitChunkManager extends ChunkManager {
+
+    public static boolean isIn(CuboidRegion region, int x, int z) {
+        return x >= region.getMinimumPoint().getX() && x <= region.getMaximumPoint().getX() && z >= region.getMinimumPoint().getZ() && z <= region.getMaximumPoint().getZ();
+    }
+
+    public static ContentMap swapChunk(World world1, World world2, Chunk pos1, Chunk pos2,
+        CuboidRegion r1, CuboidRegion r2) {
+        ContentMap map = new ContentMap();
+        int relX = r2.getMinimumPoint().getX() - r1.getMinimumPoint().getX();
+        int relZ = r2.getMinimumPoint().getZ() - r1.getMinimumPoint().getZ();
+
+        map.saveEntitiesIn(pos1, r1, relX, relZ, true);
+        map.saveEntitiesIn(pos2, r2, -relX, -relZ, true);
+
+        int sx = pos1.getX() << 4;
+        int sz = pos1.getZ() << 4;
+
+        String worldName1 = world1.getName();
+        String worldName2 = world2.getName();
+
+        BukkitWorld bukkitWorld1 = new BukkitWorld(world1);
+        BukkitWorld bukkitWorld2 = new BukkitWorld(world2);
+
+        LocalBlockQueue queue1 = GlobalBlockQueue.IMP.getNewQueue(worldName1, false);
+        LocalBlockQueue queue2 = GlobalBlockQueue.IMP.getNewQueue(worldName2, false);
+
+        for (int x = Math.max(r1.getMinimumPoint().getX(), sx); x <= Math.min(r1.getMaximumPoint().getX(), sx + 15); x++) {
+            for (int z = Math.max(r1.getMinimumPoint().getZ(), sz); z <= Math.min(r1.getMaximumPoint().getZ(), sz + 15); z++) {
+                for (int y = 0; y < 256; y++) {
+                    Block block1 = world1.getBlockAt(x, y, z);
+                    BaseBlock baseBlock1 = bukkitWorld1.getFullBlock(BlockVector3.at(x, y, z));
+                    BlockData data1 = block1.getBlockData();
+
+                    int xx = x + relX;
+                    int zz = z + relZ;
+
+                    Block block2 = world2.getBlockAt(xx, y, zz);
+                    BaseBlock baseBlock2 = bukkitWorld2.getFullBlock(BlockVector3.at(xx, y, zz));
+                    BlockData data2 = block2.getBlockData();
+
+                    if (block1.isEmpty()) {
+                        if (!block2.isEmpty()) {
+                            queue1.setBlock(x, y, z, baseBlock2);
+                            queue2.setBlock(xx, y, zz, WEExtent.AIRBASE);
+                        }
+                    } else if (block2.isEmpty()) {
+                        queue1.setBlock(x, y, z, WEExtent.AIRBASE);
+                        queue2.setBlock(xx, y, zz, baseBlock1);
+                    } else if (block1.equals(block2)) {
+                        if (!data1.matches(data2)) {
+                            block1.setBlockData(data2);
+                            block2.setBlockData(data1);
+                        }
+                    } else {
+                        queue1.setBlock(x, y, z, baseBlock2);
+                        queue2.setBlock(xx, y, zz, baseBlock1);
+                    }
+                }
+            }
+        }
+        queue1.enqueue();
+        queue2.enqueue();
+        return map;
+    }
+
+    @Override public Set<BlockVector2> getChunkChunks(String world) {
+        Set<BlockVector2> chunks = super.getChunkChunks(world);
+        for (Chunk chunk : Objects.requireNonNull(Bukkit.getWorld(world)).getLoadedChunks()) {
+            BlockVector2 loc = BlockVector2.at(chunk.getX() >> 5, chunk.getZ() >> 5);
+            chunks.add(loc);
+        }
+        return chunks;
+    }
+
+    @Override public int[] countEntities(Plot plot) {
+        int[] existing = (int[]) plot.getMeta("EntityCount");
+        if (existing != null && (System.currentTimeMillis() - (long) plot.getMeta("EntityCountTime")
+            < 1000)) {
+            return existing;
+        }
+        PlotArea area = plot.getArea();
+        World world = BukkitUtil.getWorld(area.worldname);
+
+        Location bot = plot.getBottomAbs();
+        Location top = plot.getTopAbs();
+        int bx = bot.getX() >> 4;
+        int bz = bot.getZ() >> 4;
+
+        int tx = top.getX() >> 4;
+        int tz = top.getZ() >> 4;
+
+        int size = tx - bx << 4;
+
+        Set<Chunk> chunks = new HashSet<>();
+        for (int X = bx; X <= tx; X++) {
+            for (int Z = bz; Z <= tz; Z++) {
+                if (world.isChunkLoaded(X, Z)) {
+                    chunks.add(world.getChunkAt(X, Z));
+                }
+            }
+        }
+
+        boolean doWhole = false;
+        List<Entity> entities = null;
+        if (size > 200 && chunks.size() > 200) {
+            entities = world.getEntities();
+            if (entities.size() < 16 + size / 8) {
+                doWhole = true;
+            }
+        }
+
+        int[] count = new int[6];
+        if (doWhole) {
+            for (Entity entity : entities) {
+                org.bukkit.Location location = entity.getLocation();
+                PaperLib.getChunkAtAsync(location).thenAccept( chunk -> {
+                    if (chunks.contains(chunk)) {
+                        int X = chunk.getX();
+                        int Z = chunk.getZ();
+                        if (X > bx && X < tx && Z > bz && Z < tz) {
+                            count(count, entity);
+                        } else {
+                            Plot other = area.getPlot(BukkitUtil.getLocation(location));
+                            if (plot.equals(other)) {
+                                count(count, entity);
+                            }
+                        }
+                    }
+                });
+            }
+        } else {
+            for (Chunk chunk : chunks) {
+                int X = chunk.getX();
+                int Z = chunk.getZ();
+                Entity[] entities1 = chunk.getEntities();
+                for (Entity entity : entities1) {
+                    if (X == bx || X == tx || Z == bz || Z == tz) {
+                        Plot other = area.getPlot(BukkitUtil.getLocation(entity));
+                        if (plot.equals(other)) {
+                            count(count, entity);
+                        }
+                    } else {
+                        count(count, entity);
+                    }
+                }
+            }
+        }
+        return count;
+    }
+
+    @Override public boolean copyRegion(Location pos1, Location pos2, Location newPos,
+        final Runnable whenDone) {
+        final int relX = newPos.getX() - pos1.getX();
+        final int relZ = newPos.getZ() - pos1.getZ();
+
+        final CuboidRegion region =
+            RegionUtil.createRegion(pos1.getX(), pos2.getX(), pos1.getZ(), pos2.getZ());
+        final World oldWorld = Bukkit.getWorld(pos1.getWorld());
+        final BukkitWorld oldBukkitWorld = new BukkitWorld(oldWorld);
+        final World newWorld = Bukkit.getWorld(newPos.getWorld());
+        assert newWorld != null;
+        assert oldWorld != null;
+        final String newWorldName = newWorld.getName();
+        final ContentMap map = new ContentMap();
+        final LocalBlockQueue queue = GlobalBlockQueue.IMP.getNewQueue(newWorldName, false);
+        ChunkManager.chunkTask(pos1, pos2, new RunnableVal<int[]>() {
+            @Override public void run(int[] value) {
+                int bx = value[2];
+                int bz = value[3];
+                int tx = value[4];
+                int tz = value[5];
+                BlockVector2 loc = BlockVector2.at(value[0], value[1]);
+                int cxx = loc.getX() << 4;
+                int czz = loc.getZ() << 4;
+                PaperLib.getChunkAtAsync(oldWorld, loc.getX(), loc.getZ())
+                    .thenAccept(chunk1 -> map.saveEntitiesIn(chunk1, region)).thenRun(() -> {
+                    for (int x = bx & 15; x <= (tx & 15); x++) {
+                        for (int z = bz & 15; z <= (tz & 15); z++) {
+                            map.saveBlocks(oldBukkitWorld, 256, cxx + x, czz + z, relX, relZ);
+                        }
+                    }
+                });
+            }
+        }, () -> {
+            for (Entry<PlotLoc, BaseBlock[]> entry : map.allBlocks.entrySet()) {
+                PlotLoc loc = entry.getKey();
+                BaseBlock[] blocks = entry.getValue();
+                for (int y = 0; y < blocks.length; y++) {
+                    if (blocks[y] != null) {
+                        BaseBlock block = blocks[y];
+                        queue.setBlock(loc.getX(), y, loc.getZ(), block);
+                    }
+                }
+            }
+            queue.enqueue();
+            GlobalBlockQueue.IMP.addEmptyTask(() -> {
+                //map.restoreBlocks(newWorld, 0, 0);
+                map.restoreEntities(newWorld, relX, relZ);
+                TaskManager.runTask(whenDone);
+            });
+        }, 5);
+        return true;
+    }
+
+    @Override public boolean regenerateRegion(final Location pos1, final Location pos2,
+        final boolean ignoreAugment, final Runnable whenDone) {
+        final String world = pos1.getWorld();
+
+        final int p1x = pos1.getX();
+        final int p1z = pos1.getZ();
+        final int p2x = pos2.getX();
+        final int p2z = pos2.getZ();
+        final int bcx = p1x >> 4;
+        final int bcz = p1z >> 4;
+        final int tcx = p2x >> 4;
+        final int tcz = p2z >> 4;
+
+        final List<BlockVector2> chunks = new ArrayList<>();
+
+        for (int x = bcx; x <= tcx; x++) {
+            for (int z = bcz; z <= tcz; z++) {
+                chunks.add(BlockVector2.at(x, z));
+            }
+        }
+        final World worldObj = Bukkit.getWorld(world);
+        checkNotNull(worldObj, "Critical error during regeneration.");
+        final BukkitWorld bukkitWorldObj = new BukkitWorld(worldObj);
+        TaskManager.runTask(new Runnable() {
+            @Override public void run() {
+                long start = System.currentTimeMillis();
+                while (!chunks.isEmpty() && System.currentTimeMillis() - start < 5) {
+                    final BlockVector2 chunk = chunks.remove(0);
+                    int x = chunk.getX();
+                    int z = chunk.getZ();
+                    int xxb = x << 4;
+                    int zzb = z << 4;
+                    int xxt = xxb + 15;
+                    int zzt = zzb + 15;
+                    Chunk chunkObj = worldObj.getChunkAt(x, z);
+                    if (!chunkObj.load(false)) {
+                        continue;
+                    }
+                    final LocalBlockQueue queue = GlobalBlockQueue.IMP.getNewQueue(world, false);
+                    if (xxb >= p1x && xxt <= p2x && zzb >= p1z && zzt <= p2z
+                        && PlotSquared.imp().getServerVersion()[1] == 13) {
+                        AugmentedUtils
+                            .bypass(ignoreAugment, () -> queue.regenChunkSafe(chunk.getX(), chunk.getZ()));
+                        continue;
+                    }
+                    boolean checkX1 = false;
+
+                    int xxb2;
+
+                    if (x == bcx) {
+                        xxb2 = p1x - 1;
+                        checkX1 = true;
+                    } else {
+                        xxb2 = xxb;
+                    }
+                    boolean checkX2 = false;
+                    int xxt2;
+                    if (x == tcx) {
+                        xxt2 = p2x + 1;
+                        checkX2 = true;
+                    } else {
+                        xxt2 = xxt;
+                    }
+                    boolean checkZ1 = false;
+                    int zzb2;
+                    if (z == bcz) {
+                        zzb2 = p1z - 1;
+                        checkZ1 = true;
+                    } else {
+                        zzb2 = zzb;
+                    }
+                    boolean checkZ2 = false;
+                    int zzt2;
+                    if (z == tcz) {
+                        zzt2 = p2z + 1;
+                        checkZ2 = true;
+                    } else {
+                        zzt2 = zzt;
+                    }
+                    final ContentMap map = new ContentMap();
+                    if (checkX1) {
+                        map.saveRegion(bukkitWorldObj, xxb, xxb2, zzb2, zzt2); //
+                    }
+                    if (checkX2) {
+                        map.saveRegion(bukkitWorldObj, xxt2, xxt, zzb2, zzt2); //
+                    }
+                    if (checkZ1) {
+                        map.saveRegion(bukkitWorldObj, xxb2, xxt2, zzb, zzb2); //
+                    }
+                    if (checkZ2) {
+                        map.saveRegion(bukkitWorldObj, xxb2, xxt2, zzt2, zzt); //
+                    }
+                    if (checkX1 && checkZ1) {
+                        map.saveRegion(bukkitWorldObj, xxb, xxb2, zzb, zzb2); //
+                    }
+                    if (checkX2 && checkZ1) {
+                        map.saveRegion(bukkitWorldObj, xxt2, xxt, zzb, zzb2); // ?
+                    }
+                    if (checkX1 && checkZ2) {
+                        map.saveRegion(bukkitWorldObj, xxb, xxb2, zzt2, zzt); // ?
+                    }
+                    if (checkX2 && checkZ2) {
+                        map.saveRegion(bukkitWorldObj, xxt2, xxt, zzt2, zzt); //
+                    }
+                    CuboidRegion currentPlotClear =
+                        RegionUtil.createRegion(pos1.getX(), pos2.getX(), pos1.getZ(), pos2.getZ());
+                    map.saveEntitiesOut(chunkObj, currentPlotClear);
+                    AugmentedUtils.bypass(ignoreAugment,
+                        () -> setChunkInPlotArea(null, new RunnableVal<ScopedLocalBlockQueue>() {
+                            @Override public void run(ScopedLocalBlockQueue value) {
+                                Location min = value.getMin();
+                                int bx = min.getX();
+                                int bz = min.getZ();
+                                for (int x1 = 0; x1 < 16; x1++) {
+                                    for (int z1 = 0; z1 < 16; z1++) {
+                                        PlotLoc plotLoc = new PlotLoc(bx + x1, bz + z1);
+                                        BaseBlock[] ids = map.allBlocks.get(plotLoc);
+                                        if (ids != null) {
+                                            for (int y = 0; y < Math.min(128, ids.length); y++) {
+                                                BaseBlock id = ids[y];
+                                                if (id != null) {
+                                                    value.setBlock(x1, y, z1, id);
+                                                } else {
+                                                    value.setBlock(x1, y, z1, BlockTypes.AIR.getDefaultState());
+                                                }
+                                            }
+                                            for (int y = Math.min(128, ids.length);
+                                                 y < ids.length; y++) {
+                                                BaseBlock id = ids[y];
+                                                if (id != null) {
+                                                    value.setBlock(x1, y, z1, id);
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }, world, chunk));
+                    //map.restoreBlocks(worldObj, 0, 0);
+                    map.restoreEntities(worldObj, 0, 0);
+                }
+                if (!chunks.isEmpty()) {
+                    TaskManager.runTaskLater(this, 1);
+                } else {
+                    TaskManager.runTaskLater(whenDone, 1);
+                }
+            }
+        });
+        return true;
+    }
+
+    @Override public CompletableFuture<?> loadChunk(String world, BlockVector2 chunkLoc, boolean force) {
+        return PaperLib.getChunkAtAsync(BukkitUtil.getWorld(world),chunkLoc.getX(), chunkLoc.getZ(), force);
+    }
+
+    @Override
+    public void unloadChunk(final String world, final BlockVector2 chunkLoc, final boolean save) {
+        if (!PlotSquared.get().isMainThread(Thread.currentThread())) {
+            TaskManager.runTask(
+                () -> BukkitUtil.getWorld(world).unloadChunk(chunkLoc.getX(), chunkLoc.getZ(), save));
+        } else {
+            BukkitUtil.getWorld(world).unloadChunk(chunkLoc.getX(), chunkLoc.getZ(), save);
+        }
+    }
+
+    @Override public void clearAllEntities(Location pos1, Location pos2) {
+        String world = pos1.getWorld();
+        List<Entity> entities = BukkitUtil.getEntities(world);
+        int bx = pos1.getX();
+        int bz = pos1.getZ();
+        int tx = pos2.getX();
+        int tz = pos2.getZ();
+        for (Entity entity : entities) {
+            if (!(entity instanceof Player)) {
+                org.bukkit.Location location = entity.getLocation();
+                if (location.getX() >= bx && location.getX() <= tx && location.getZ() >= bz
+                    && location.getZ() <= tz) {
+                    if (entity.hasMetadata("ps-tmp-teleport")) {
+                        continue;
+                    }
+                    entity.remove();
+                }
+            }
+        }
+    }
+
+    @Override public void swap(Location bot1, Location top1, Location bot2, Location top2,
+        final Runnable whenDone) {
+        CuboidRegion region1 =
+            RegionUtil.createRegion(bot1.getX(), top1.getX(), bot1.getZ(), top1.getZ());
+        CuboidRegion region2 =
+            RegionUtil.createRegion(bot2.getX(), top2.getX(), bot2.getZ(), top2.getZ());
+        final World world1 = Bukkit.getWorld(bot1.getWorld());
+        final World world2 = Bukkit.getWorld(bot2.getWorld());
+        checkNotNull(world1,"Critical error during swap.");
+        checkNotNull(world2,"Critical error during swap.");
+        int relX = bot2.getX() - bot1.getX();
+        int relZ = bot2.getZ() - bot1.getZ();
+
+        final ArrayDeque<ContentMap> maps = new ArrayDeque<>();
+
+        for (int x = bot1.getX() >> 4; x <= top1.getX() >> 4; x++) {
+            for (int z = bot1.getZ() >> 4; z <= top1.getZ() >> 4; z++) {
+                Chunk chunk1 = world1.getChunkAt(x, z);
+                Chunk chunk2 = world2.getChunkAt(x + (relX >> 4), z + (relZ >> 4));
+                maps.add(swapChunk(world1, world2, chunk1, chunk2, region1, region2));
+            }
+        }
+        GlobalBlockQueue.IMP.addEmptyTask(() -> {
+            for (ContentMap map : maps) {
+                map.restoreEntities(world1, 0, 0);
+                TaskManager.runTaskLater(whenDone, 1);
+            }
+        });
+    }
+
+    private void count(int[] count, Entity entity) {
+        switch (entity.getType()) {
+            case PLAYER:
+                // not valid
+                return;
+            case SMALL_FIREBALL:
+            case FIREBALL:
+            case DROPPED_ITEM:
+            case EGG:
+            case THROWN_EXP_BOTTLE:
+            case SPLASH_POTION:
+            case SNOWBALL:
+            case ENDER_PEARL:
+            case ARROW:
+            case TRIDENT:
+            case SHULKER_BULLET:
+            case SPECTRAL_ARROW:
+            case DRAGON_FIREBALL:
+            case LLAMA_SPIT:
+                // projectile
+            case PRIMED_TNT:
+            case FALLING_BLOCK:
+                // Block entities
+            case ENDER_CRYSTAL:
+            case FISHING_HOOK:
+            case ENDER_SIGNAL:
+            case EXPERIENCE_ORB:
+            case LEASH_HITCH:
+            case FIREWORK:
+            case LIGHTNING:
+            case WITHER_SKULL:
+            case UNKNOWN:
+            case AREA_EFFECT_CLOUD:
+            case EVOKER_FANGS:
+                // non moving / unremovable
+                break;
+            case ITEM_FRAME:
+            case PAINTING:
+            case ARMOR_STAND:
+                count[5]++;
+                break;
+            // misc
+            case MINECART:
+            case MINECART_CHEST:
+            case MINECART_COMMAND:
+            case MINECART_FURNACE:
+            case MINECART_HOPPER:
+            case MINECART_MOB_SPAWNER:
+            case MINECART_TNT:
+            case BOAT:
+                count[4]++;
+                break;
+            case POLAR_BEAR:
+            case RABBIT:
+            case SHEEP:
+            case MUSHROOM_COW:
+            case OCELOT:
+            case PIG:
+            case HORSE:
+            case SQUID:
+            case VILLAGER:
+            case IRON_GOLEM:
+            case WOLF:
+            case CHICKEN:
+            case COW:
+            case SNOWMAN:
+            case BAT:
+            case DONKEY:
+            case LLAMA:
+            case SKELETON_HORSE:
+            case ZOMBIE_HORSE:
+            case MULE:
+            case DOLPHIN:
+            case TURTLE:
+            case COD:
+            case PARROT:
+            case SALMON:
+            case PUFFERFISH:
+            case TROPICAL_FISH:
+            case CAT:
+            case FOX:
+            case PANDA:
+                // animal
+                count[3]++;
+                count[1]++;
+                break;
+            case BLAZE:
+            case CAVE_SPIDER:
+            case CREEPER:
+            case ENDERMAN:
+            case ENDERMITE:
+            case ENDER_DRAGON:
+            case GHAST:
+            case GIANT:
+            case GUARDIAN:
+            case MAGMA_CUBE:
+            case PIG_ZOMBIE:
+            case SILVERFISH:
+            case SKELETON:
+            case SLIME:
+            case SPIDER:
+            case WITCH:
+            case WITHER:
+            case ZOMBIE:
+            case SHULKER:
+            case ELDER_GUARDIAN:
+            case STRAY:
+            case HUSK:
+            case EVOKER:
+            case VEX:
+            case WITHER_SKELETON:
+            case ZOMBIE_VILLAGER:
+            case VINDICATOR:
+                // monster
+                count[3]++;
+                count[2]++;
+                break;
+            default:
+                if (entity instanceof Creature) {
+                    count[3]++;
+                    if (entity instanceof Animals) {
+                        count[1]++;
+                    } else {
+                        count[2]++;
+                    }
+                } else {
+                    count[4]++;
+                }
+        }
+        count[0]++;
+    }
+
+
+    public static class ContentMap {
+
+        final Set<EntityWrapper> entities;
+        final Map<PlotLoc, BaseBlock[]> allBlocks;
+
+        ContentMap() {
+            this.entities = new HashSet<>();
+            this.allBlocks = new HashMap<>();
+        }
+
+        public void saveRegion(BukkitWorld world, int x1, int x2, int z1, int z2) {
+            if (z1 > z2) {
+                int tmp = z1;
+                z1 = z2;
+                z2 = tmp;
+            }
+            if (x1 > x2) {
+                int tmp = x1;
+                x1 = x2;
+                x2 = tmp;
+            }
+            for (int x = x1; x <= x2; x++) {
+                for (int z = z1; z <= z2; z++) {
+                    saveBlocks(world, 256, x, z, 0, 0);
+                }
+            }
+        }
+
+        void saveEntitiesOut(Chunk chunk, CuboidRegion region) {
+            for (Entity entity : chunk.getEntities()) {
+                Location location = BukkitUtil.getLocation(entity);
+                int x = location.getX();
+                int z = location.getZ();
+                if (isIn(region, x, z)) {
+                    continue;
+                }
+                if (entity.getVehicle() != null) {
+                    continue;
+                }
+                EntityWrapper wrap = new ReplicatingEntityWrapper(entity, (short) 2);
+                wrap.saveEntity();
+                this.entities.add(wrap);
+            }
+        }
+
+        void saveEntitiesIn(Chunk chunk, CuboidRegion region) {
+            saveEntitiesIn(chunk, region, 0, 0, false);
+        }
+
+        void saveEntitiesIn(Chunk chunk, CuboidRegion region, int offsetX, int offsetZ,
+            boolean delete) {
+            for (Entity entity : chunk.getEntities()) {
+                Location location = BukkitUtil.getLocation(entity);
+                int x = location.getX();
+                int z = location.getZ();
+                if (!isIn(region, x, z)) {
+                    continue;
+                }
+                if (entity.getVehicle() != null) {
+                    continue;
+                }
+                EntityWrapper wrap = new ReplicatingEntityWrapper(entity, (short) 2);
+                wrap.x += offsetX;
+                wrap.z += offsetZ;
+                wrap.saveEntity();
+                this.entities.add(wrap);
+                if (delete) {
+                    if (!(entity instanceof Player)) {
+                        entity.remove();
+                    }
+                }
+            }
+        }
+
+        void restoreEntities(World world, int xOffset, int zOffset) {
+            for (EntityWrapper entity : this.entities) {
+                try {
+                    entity.spawn(world, xOffset, zOffset);
+                } catch (Exception e) {
+                    PlotSquared.debug("Failed to restore entity (e): " + e.toString());
+                    e.printStackTrace();
+                }
+            }
+            this.entities.clear();
+        }
+
+        //todo optimize maxY
+        void saveBlocks(BukkitWorld world, int maxY, int x, int z, int offsetX, int offsetZ) {
+            maxY = Math.min(255, maxY);
+            BaseBlock[] ids = new BaseBlock[maxY + 1];
+            for (short y = 0; y <= maxY; y++) {
+                BaseBlock block = world.getFullBlock(BlockVector3.at(x, y, z));
+                ids[y] = block;
+            }
+            PlotLoc loc = new PlotLoc(x + offsetX, z + offsetZ);
+            this.allBlocks.put(loc, ids);
+        }
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitCommand.java

@@ -0,0 +1,61 @@
+package com.github.intellectualsites.plotsquared.bukkit.util;
+
+import com.github.intellectualsites.plotsquared.bukkit.commands.DebugUUID;
+import com.github.intellectualsites.plotsquared.plot.commands.MainCommand;
+import com.github.intellectualsites.plotsquared.plot.object.ConsolePlayer;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.command.ProxiedCommandSender;
+import org.bukkit.command.RemoteConsoleCommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+public class BukkitCommand implements CommandExecutor, TabCompleter {
+
+    public BukkitCommand() {
+        new DebugUUID();
+    }
+
+    @Override
+    public boolean onCommand(CommandSender commandSender, Command command, String commandLabel,
+        String[] args) {
+        if (commandSender instanceof Player) {
+            return MainCommand.onCommand(BukkitUtil.getPlayer((Player) commandSender), args);
+        }
+        if (commandSender instanceof ConsoleCommandSender
+            || commandSender instanceof ProxiedCommandSender
+            || commandSender instanceof RemoteConsoleCommandSender) {
+            return MainCommand.onCommand(ConsolePlayer.getConsole(), args);
+        }
+        return false;
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender commandSender, Command command, String s,
+        String[] args) {
+        if (!(commandSender instanceof Player)) {
+            return null;
+        }
+        PlotPlayer player = BukkitUtil.getPlayer((Player) commandSender);
+        if (args.length == 0) {
+            return Collections.singletonList("plots");
+        }
+        Collection<com.github.intellectualsites.plotsquared.commands.Command> objects = MainCommand.getInstance().tab(player, args, s.endsWith(" "));
+        if (objects == null) {
+            return null;
+        }
+        List<String> result = new ArrayList<>();
+        for (com.github.intellectualsites.plotsquared.commands.Command o : objects) {
+            result.add(o.toString());
+        }
+        return result.isEmpty() ? null : result;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitEconHandler.java

@@ -0,0 +1,83 @@
+package com.github.intellectualsites.plotsquared.bukkit.util;
+
+import com.github.intellectualsites.plotsquared.bukkit.object.BukkitOfflinePlayer;
+import com.github.intellectualsites.plotsquared.bukkit.object.BukkitPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.OfflinePlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.util.EconHandler;
+import net.milkbowl.vault.economy.Economy;
+import net.milkbowl.vault.permission.Permission;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.RegisteredServiceProvider;
+
+public class BukkitEconHandler extends EconHandler {
+
+    private Economy econ;
+    private Permission perms;
+
+    public boolean init() {
+        if (this.econ == null || this.perms == null) {
+            setupPermissions();
+            setupEconomy();
+        }
+        return this.econ != null && this.perms != null;
+    }
+
+    private boolean setupPermissions() {
+        RegisteredServiceProvider<Permission> permissionProvider =
+            Bukkit.getServer().getServicesManager().getRegistration(Permission.class);
+        if (permissionProvider != null) {
+            this.perms = permissionProvider.getProvider();
+        }
+        return this.perms != null;
+    }
+
+    private boolean setupEconomy() {
+        if (Bukkit.getServer().getPluginManager().getPlugin("Vault") == null) {
+            return false;
+        }
+        RegisteredServiceProvider<Economy> economyProvider =
+            Bukkit.getServer().getServicesManager().getRegistration(Economy.class);
+        if (economyProvider != null) {
+            this.econ = economyProvider.getProvider();
+        }
+        return this.econ != null;
+    }
+
+    @Override public double getMoney(PlotPlayer player) {
+        double bal = super.getMoney(player);
+        if (Double.isNaN(bal)) {
+            return this.econ.getBalance(((BukkitPlayer) player).player);
+        }
+        return bal;
+    }
+
+    @Override public void withdrawMoney(PlotPlayer player, double amount) {
+        this.econ.withdrawPlayer(((BukkitPlayer) player).player, amount);
+    }
+
+    @Override public void depositMoney(PlotPlayer player, double amount) {
+        this.econ.depositPlayer(((BukkitPlayer) player).player, amount);
+    }
+
+    @Override public void depositMoney(OfflinePlotPlayer player, double amount) {
+        this.econ.depositPlayer(((BukkitOfflinePlayer) player).player, amount);
+    }
+
+    @Override public boolean hasPermission(String world, String player, String perm) {
+        return this.perms.playerHas(world, Bukkit.getOfflinePlayer(player), perm);
+    }
+
+    @Override public double getBalance(PlotPlayer player) {
+        return this.econ.getBalance(player.getName());
+    }
+
+    public void setPermission(String world, String player, String perm, boolean value) {
+        if (value) {
+            this.perms.playerAdd(world, player, perm);
+        } else {
+            this.perms.playerRemove(world, player, perm);
+        }
+    }
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitEventUtil.java

@@ -0,0 +1,145 @@
+package com.github.intellectualsites.plotsquared.bukkit.util;
+
+import com.github.intellectualsites.plotsquared.bukkit.events.PlayerClaimPlotEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlayerEnterPlotEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlayerLeavePlotEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlayerPlotDeniedEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlayerPlotHelperEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlayerPlotTrustedEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlayerTeleportToPlotEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlotAutoMergeEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlotChangeOwnerEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlotClearEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlotComponentSetEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlotDeleteEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlotFlagAddEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlotFlagRemoveEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlotMergeEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlotRateEvent;
+import com.github.intellectualsites.plotsquared.bukkit.events.PlotUnlinkEvent;
+import com.github.intellectualsites.plotsquared.bukkit.object.BukkitPlayer;
+import com.github.intellectualsites.plotsquared.plot.flag.Flag;
+import com.github.intellectualsites.plotsquared.plot.object.Location;
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.object.PlotArea;
+import com.github.intellectualsites.plotsquared.plot.object.PlotId;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.Rating;
+import com.github.intellectualsites.plotsquared.plot.object.TeleportCause;
+import com.github.intellectualsites.plotsquared.plot.util.EventUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.player.PlayerTeleportEvent;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * Utility class for handling Bukkit Events.
+ */
+public final class BukkitEventUtil extends EventUtil {
+
+    @Nullable public Player getPlayer(final PlotPlayer player) {
+        if (player instanceof BukkitPlayer) {
+            return ((BukkitPlayer) player).player;
+        }
+        return null;
+    }
+
+    private boolean callEvent(@NotNull final Event event) {
+        Bukkit.getServer().getPluginManager().callEvent(event);
+        return !(event instanceof Cancellable) || !((Cancellable) event).isCancelled();
+    }
+
+    @Override public boolean callClaim(PlotPlayer player, Plot plot, boolean auto) {
+        return callEvent(new PlayerClaimPlotEvent(getPlayer(player), plot, auto));
+    }
+
+    @Override public boolean callTeleport(PlotPlayer player, Location from, Plot plot) {
+        return callEvent(new PlayerTeleportToPlotEvent(getPlayer(player), from, plot));
+    }
+
+    @Override public boolean callComponentSet(Plot plot, String component) {
+        return callEvent(new PlotComponentSetEvent(plot, component));
+    }
+
+    @Override public boolean callClear(Plot plot) {
+        return callEvent(new PlotClearEvent(plot));
+    }
+
+    @Override public boolean callDelete(Plot plot) {
+        return callEvent(new PlotDeleteEvent(plot));
+    }
+
+    @Override public boolean callFlagAdd(Flag flag, Plot plot) {
+        return callEvent(new PlotFlagAddEvent(flag, plot));
+    }
+
+    @Override public boolean callFlagRemove(Flag<?> flag, Plot plot, Object value) {
+        return callEvent(new PlotFlagRemoveEvent(flag, plot));
+    }
+
+    @Override public boolean callMerge(Plot plot, int dir, int max) {
+        return callEvent(
+            new PlotMergeEvent(BukkitUtil.getWorld(plot.getWorldName()), plot, dir, max));
+    }
+
+    @Override public boolean callAutoMerge(Plot plot, List<PlotId> plots) {
+        return callEvent(
+            new PlotAutoMergeEvent(BukkitUtil.getWorld(plot.getWorldName()), plot, plots));
+    }
+
+    @Override public boolean callUnlink(PlotArea area, List<PlotId> plots) {
+        return callEvent(new PlotUnlinkEvent(BukkitUtil.getWorld(area.worldname), area, plots));
+    }
+
+    @Override public void callEntry(PlotPlayer player, Plot plot) {
+        callEvent(new PlayerEnterPlotEvent(getPlayer(player), plot));
+    }
+
+    @Override public void callLeave(PlotPlayer player, Plot plot) {
+        callEvent(new PlayerLeavePlotEvent(getPlayer(player), plot));
+    }
+
+    @Override public void callDenied(PlotPlayer initiator, Plot plot, UUID player, boolean added) {
+        callEvent(new PlayerPlotDeniedEvent(getPlayer(initiator), plot, player, added));
+    }
+
+    @Override public void callTrusted(PlotPlayer initiator, Plot plot, UUID player, boolean added) {
+        callEvent(new PlayerPlotTrustedEvent(getPlayer(initiator), plot, player, added));
+    }
+
+    @Override public void callMember(PlotPlayer initiator, Plot plot, UUID player, boolean added) {
+        callEvent(new PlayerPlotHelperEvent(getPlayer(initiator), plot, player, added));
+    }
+
+    @Override
+    public boolean callOwnerChange(PlotPlayer initiator, Plot plot, UUID oldOwner, UUID newOwner,
+        boolean hasOldOwner) {
+        return callEvent(
+            new PlotChangeOwnerEvent(getPlayer(initiator), plot, oldOwner, newOwner, hasOldOwner));
+    }
+
+    @Override @Nullable public Rating callRating(PlotPlayer player, Plot plot, Rating rating) {
+        PlotRateEvent event = new PlotRateEvent(player, rating, plot);
+        Bukkit.getServer().getPluginManager().callEvent(event);
+        if (event.isCancelled()) {
+            return null;
+        }
+        return event.getRating();
+    }
+
+    public PlayerTeleportEvent.TeleportCause getTeleportCause(@NotNull final TeleportCause cause) {
+        switch (cause) {
+            case COMMAND:
+                return PlayerTeleportEvent.TeleportCause.COMMAND;
+            case PLUGIN:
+                return PlayerTeleportEvent.TeleportCause.PLUGIN;
+            default: return PlayerTeleportEvent.TeleportCause.UNKNOWN;
+        }
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitHybridUtils.java

@@ -0,0 +1,8 @@
+package com.github.intellectualsites.plotsquared.bukkit.util;
+
+import com.github.intellectualsites.plotsquared.plot.generator.HybridUtils;
+
+public class BukkitHybridUtils extends HybridUtils {
+
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitInventoryUtil.java

@@ -1,10 +1,14 @@
-package com.plotsquared.bukkit.util;
-
-import java.util.ArrayList;
-import java.util.List;
+package com.github.intellectualsites.plotsquared.bukkit.util;
 
+import com.github.intellectualsites.plotsquared.bukkit.object.BukkitPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.PlotInventory;
+import com.github.intellectualsites.plotsquared.plot.object.PlotItemStack;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.util.InventoryUtil;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
+import org.bukkit.Material;
 import org.bukkit.event.inventory.InventoryType;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.InventoryView;
@@ -12,17 +16,14 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.PlayerInventory;
 import org.bukkit.inventory.meta.ItemMeta;
 
-import com.intellectualcrafters.plot.object.PlotInventory;
-import com.intellectualcrafters.plot.object.PlotItemStack;
-import com.intellectualcrafters.plot.object.PlotPlayer;
-import com.intellectualcrafters.plot.util.InventoryUtil;
-import com.plotsquared.bukkit.object.BukkitPlayer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.IntStream;
 
 public class BukkitInventoryUtil extends InventoryUtil {
 
-    @Override
-    public void open(PlotInventory inv) {
-        BukkitPlayer bp = ((BukkitPlayer) inv.player); 
+    @Override public void open(PlotInventory inv) {
+        BukkitPlayer bp = (BukkitPlayer) inv.player;
         Inventory inventory = Bukkit.createInventory(null, inv.size * 9, inv.getTitle());
         PlotItemStack[] items = inv.getItems();
         for (int i = 0; i < inv.size * 9; i++) {
@@ -31,23 +32,19 @@ public class BukkitInventoryUtil extends InventoryUtil {
                 inventory.setItem(i, getItem(item));
             }
         }
-        inv.player.setMeta("inventory", inv);
         bp.player.openInventory(inventory);
     }
 
-    @Override
-    public void close(PlotInventory inv) {
+    @Override public void close(PlotInventory inv) {
         if (!inv.isOpen()) {
             return;
         }
-        inv.player.deleteMeta("inventory");
-        BukkitPlayer bp = ((BukkitPlayer) inv.player);
+        BukkitPlayer bp = (BukkitPlayer) inv.player;
         bp.player.closeInventory();
     }
 
-    @Override
-    public void setItem(PlotInventory inv, int index, PlotItemStack item) {
-        BukkitPlayer bp = ((BukkitPlayer) inv.player);
+    @Override public void setItem(PlotInventory inv, int index, PlotItemStack item) {
+        BukkitPlayer bp = (BukkitPlayer) inv.player;
         InventoryView opened = bp.player.getOpenInventory();
         if (!inv.isOpen()) {
             return;
@@ -55,34 +52,12 @@ public class BukkitInventoryUtil extends InventoryUtil {
         opened.setItem(index, getItem(item));
         bp.player.updateInventory();
     }
-    
-    public PlotItemStack getItem(ItemStack item ) {
+
+    private static ItemStack getItem(PlotItemStack item) {
         if (item == null) {
             return null;
         }
-        int id = item.getTypeId();
-        short data = item.getDurability();
-        int amount = item.getAmount();
-        String name = null;
-        String[] lore = null;
-        if (item.hasItemMeta()) {
-            ItemMeta meta = item.getItemMeta();
-            if (meta.hasDisplayName()) {
-                name = meta.getDisplayName();
-            }
-            if (meta.hasLore()) {
-                List<String> itemLore = meta.getLore();
-                lore = itemLore.toArray(new String[itemLore.size()]);
-            }
-        }
-        return new PlotItemStack(id, data, amount, name, lore);
-    }
-    
-    public static ItemStack getItem(PlotItemStack item) {
-        if (item == null) {
-            return null;
-        }
-        ItemStack stack = new ItemStack(item.id, item.amount, item.data);
+        ItemStack stack = new ItemStack(BukkitAdapter.adapt(item.getType()), item.amount);
         ItemMeta meta = null;
         if (item.name != null) {
             meta = stack.getItemMeta();
@@ -104,24 +79,48 @@ public class BukkitInventoryUtil extends InventoryUtil {
         return stack;
     }
 
-    @Override
-    public PlotItemStack[] getItems(PlotPlayer player) {
-        BukkitPlayer bp = ((BukkitPlayer) player);
-        PlayerInventory inv = bp.player.getInventory();
-        PlotItemStack[] items = new PlotItemStack[36];
-        for (int i = 0; i < 36; i++) {
-            items[i] = getItem(inv.getItem(i));
+    public PlotItemStack getItem(ItemStack item) {
+        if (item == null) {
+            return null;
         }
-        return items;
+        // int id = item.getTypeId();
+        Material id = item.getType();
+        ItemMeta meta = item.getItemMeta();
+        int amount = item.getAmount();
+        String name = null;
+        String[] lore = null;
+        if (item.hasItemMeta()) {
+            assert meta != null;
+            if (meta.hasDisplayName()) {
+                name = meta.getDisplayName();
+            }
+            if (meta.hasLore()) {
+                List<String> itemLore = meta.getLore();
+                assert itemLore != null;
+                lore = itemLore.toArray(new String[0]);
+            }
+        }
+        return new PlotItemStack(id.name(), amount, name, lore);
     }
 
-    @Override
-    public boolean isOpen(PlotInventory inv) {
-        if (!inv.isOpen()) {
+    @Override public PlotItemStack[] getItems(PlotPlayer player) {
+        BukkitPlayer bp = (BukkitPlayer) player;
+        PlayerInventory inv = bp.player.getInventory();
+        return IntStream.range(0, 36).mapToObj(i -> getItem(inv.getItem(i)))
+            .toArray(PlotItemStack[]::new);
+    }
+
+    @Override public boolean isOpen(PlotInventory plotInventory) {
+        if (!plotInventory.isOpen()) {
             return false;
         }
-        BukkitPlayer bp = ((BukkitPlayer) inv.player);
+        BukkitPlayer bp = (BukkitPlayer) plotInventory.player;
         InventoryView opened = bp.player.getOpenInventory();
-        return (inv.isOpen() && opened.getType() == InventoryType.CRAFTING && opened.getTitle() == null);
+        if (plotInventory.isOpen()) {
+            if (opened.getType() == InventoryType.CRAFTING) {
+                opened.getTitle();
+            }
+        }
+        return false;
     }
 }

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitSchematicHandler.java

@@ -0,0 +1,213 @@
+package com.github.intellectualsites.plotsquared.bukkit.util;
+
+import com.github.intellectualsites.plotsquared.bukkit.object.schematic.StateWrapper;
+import com.github.intellectualsites.plotsquared.plot.object.Location;
+import com.github.intellectualsites.plotsquared.plot.object.RunnableVal;
+import com.github.intellectualsites.plotsquared.plot.util.MainUtil;
+import com.github.intellectualsites.plotsquared.plot.util.SchematicHandler;
+import com.github.intellectualsites.plotsquared.plot.util.TaskManager;
+import com.github.intellectualsites.plotsquared.plot.util.block.LocalBlockQueue;
+import com.sk89q.jnbt.ByteArrayTag;
+import com.sk89q.jnbt.CompoundTag;
+import com.sk89q.jnbt.IntArrayTag;
+import com.sk89q.jnbt.IntTag;
+import com.sk89q.jnbt.ListTag;
+import com.sk89q.jnbt.ShortTag;
+import com.sk89q.jnbt.StringTag;
+import com.sk89q.jnbt.Tag;
+import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldedit.regions.CuboidRegion;
+import com.sk89q.worldedit.world.block.BaseBlock;
+
+import java.io.ByteArrayOutputStream;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.IntStream;
+
+/**
+ * Schematic Handler.
+ */
+public class BukkitSchematicHandler extends SchematicHandler {
+
+    @Override public void getCompoundTag(final String world, final Set<CuboidRegion> regions,
+        final RunnableVal<CompoundTag> whenDone) {
+        // async
+        TaskManager.runTaskAsync(new Runnable() {
+            @Override public void run() {
+                // Main positions
+                Location[] corners = MainUtil.getCorners(world, regions);
+                final Location bot = corners[0];
+                final Location top = corners[1];
+
+                CuboidRegion cuboidRegion =
+                    new CuboidRegion(BukkitUtil.IMP.getWeWorld(world), bot.getBlockVector3(),
+                        top.getBlockVector3());
+
+                final int width = cuboidRegion.getWidth();
+                int height = cuboidRegion.getHeight();
+                final int length = cuboidRegion.getLength();
+                Map<String, Tag> schematic = new HashMap<>();
+                schematic.put("Version", new IntTag(1));
+
+                Map<String, Tag> metadata = new HashMap<>();
+                metadata.put("WEOffsetX", new IntTag(0));
+                metadata.put("WEOffsetY", new IntTag(0));
+                metadata.put("WEOffsetZ", new IntTag(0));
+
+                schematic.put("Metadata", new CompoundTag(metadata));
+
+                schematic.put("Width", new ShortTag((short) width));
+                schematic.put("Height", new ShortTag((short) height));
+                schematic.put("Length", new ShortTag((short) length));
+
+                // The Sponge format Offset refers to the 'min' points location in the world. That's our 'Origin'
+                schematic.put("Offset", new IntArrayTag(new int[] {0, 0, 0,}));
+
+                Map<String, Integer> palette = new HashMap<>();
+
+                List<CompoundTag> tileEntities = new ArrayList<>();
+                ByteArrayOutputStream buffer = new ByteArrayOutputStream(width * height * length);
+                // Queue
+                final ArrayDeque<CuboidRegion> queue = new ArrayDeque<>(regions);
+                TaskManager.runTask(new Runnable() {
+                    @Override public void run() {
+                        if (queue.isEmpty()) {
+                            TaskManager.runTaskAsync(() -> {
+                                schematic.put("PaletteMax", new IntTag(palette.size()));
+
+                                Map<String, Tag> paletteTag = new HashMap<>();
+                                palette.forEach(
+                                    (key, value) -> paletteTag.put(key, new IntTag(value)));
+
+                                schematic.put("Palette", new CompoundTag(paletteTag));
+                                schematic.put("BlockData", new ByteArrayTag(buffer.toByteArray()));
+                                schematic.put("TileEntities",
+                                    new ListTag(CompoundTag.class, tileEntities));
+                                whenDone.value = new CompoundTag(schematic);
+                                TaskManager.runTask(whenDone);
+                            });
+                            return;
+                        }
+                        final Runnable regionTask = this;
+                        CuboidRegion region = queue.poll();
+                        Location pos1 = new Location(world, region.getMinimumPoint().getX(), region.getMinimumPoint().getY(), region.getMinimumPoint().getZ());
+                        Location pos2 = new Location(world, region.getMaximumPoint().getX(), region.getMaximumPoint().getY(), region.getMaximumPoint().getZ());
+                        final int p1x = pos1.getX();
+                        final int sy = pos1.getY();
+                        final int p1z = pos1.getZ();
+                        final int p2x = pos2.getX();
+                        final int p2z = pos2.getZ();
+                        final int ey = pos2.getY();
+                        Iterator<Integer> yiter = IntStream.range(sy, ey + 1).iterator();
+                        final Runnable yTask = new Runnable() {
+                            @Override public void run() {
+                                long ystart = System.currentTimeMillis();
+                                while (yiter.hasNext()
+                                    && System.currentTimeMillis() - ystart < 20) {
+                                    final int y = yiter.next();
+                                    Iterator<Integer> ziter =
+                                        IntStream.range(p1z, p2z + 1).iterator();
+                                    final Runnable zTask = new Runnable() {
+                                        @Override public void run() {
+                                            long zstart = System.currentTimeMillis();
+                                            while (ziter.hasNext()
+                                                && System.currentTimeMillis() - zstart < 20) {
+                                                final int z = ziter.next();
+                                                Iterator<Integer> xiter =
+                                                    IntStream.range(p1x, p2x + 1).iterator();
+                                                final Runnable xTask = new Runnable() {
+                                                    @Override public void run() {
+                                                        long xstart = System.currentTimeMillis();
+                                                        final int ry = y - sy;
+                                                        final int rz = z - p1z;
+                                                        while (xiter.hasNext()
+                                                            && System.currentTimeMillis() - xstart
+                                                            < 20) {
+                                                            final int x = xiter.next();
+                                                            final int rx = x - p1x;
+                                                            BlockVector3 point =
+                                                                BlockVector3.at(x, y, z);
+                                                            BaseBlock block =
+                                                                cuboidRegion.getWorld()
+                                                                    .getFullBlock(point);
+                                                            if (block.getNbtData() != null) {
+                                                                Map<String, Tag> values =
+                                                                    new HashMap<>();
+                                                                for (Map.Entry<String, Tag> entry : block
+                                                                    .getNbtData().getValue()
+                                                                    .entrySet()) {
+                                                                    values.put(entry.getKey(),
+                                                                        entry.getValue());
+                                                                }
+                                                                // Remove 'id' if it exists. We want 'Id'
+                                                                values.remove("id");
+
+                                                                // Positions are kept in NBT, we don't want that.
+                                                                values.remove("x");
+                                                                values.remove("y");
+                                                                values.remove("z");
+
+                                                                values.put("Id", new StringTag(
+                                                                    block.getNbtId()));
+                                                                values.put("Pos", new IntArrayTag(
+                                                                    new int[] {rx, ry, rz}));
+
+                                                                tileEntities
+                                                                    .add(new CompoundTag(values));
+                                                            }
+                                                            String blockKey =
+                                                                block.toImmutableState()
+                                                                    .getAsString();
+                                                            int blockId;
+                                                            if (palette.containsKey(blockKey)) {
+                                                                blockId = palette.get(blockKey);
+                                                            } else {
+                                                                blockId = palette.size();
+                                                                palette
+                                                                    .put(blockKey, palette.size());
+                                                            }
+
+                                                            while ((blockId & -128) != 0) {
+                                                                buffer.write(blockId & 127 | 128);
+                                                                blockId >>>= 7;
+                                                            }
+                                                            buffer.write(blockId);
+                                                        }
+                                                        if (xiter.hasNext()) {
+                                                            this.run();
+                                                        }
+                                                    }
+                                                };
+                                                xTask.run();
+                                            }
+                                            if (ziter.hasNext()) {
+                                                this.run();
+                                            }
+                                        }
+                                    };
+                                    zTask.run();
+                                }
+                                if (yiter.hasNext()) {
+                                    TaskManager.runTaskLater(this, 1);
+                                } else {
+                                    regionTask.run();
+                                }
+                            }
+                        };
+                        yTask.run();
+                    }
+                });
+            }
+        });
+    }
+
+    @Override
+    public boolean restoreTile(LocalBlockQueue queue, CompoundTag ct, int x, int y, int z) {
+        return new StateWrapper(ct).restoreTag(queue.getWorld(), x, y, z);
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitSetupUtils.java

@@ -0,0 +1,243 @@
+package com.github.intellectualsites.plotsquared.bukkit.util;
+
+import com.github.intellectualsites.plotsquared.bukkit.generator.BukkitPlotGenerator;
+import com.github.intellectualsites.plotsquared.configuration.ConfigurationSection;
+import com.github.intellectualsites.plotsquared.configuration.file.YamlConfiguration;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.config.ConfigurationNode;
+import com.github.intellectualsites.plotsquared.plot.generator.GeneratorWrapper;
+import com.github.intellectualsites.plotsquared.plot.object.PlotArea;
+import com.github.intellectualsites.plotsquared.plot.object.SetupObject;
+import com.github.intellectualsites.plotsquared.plot.util.SetupUtils;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.World.Environment;
+import org.bukkit.WorldCreator;
+import org.bukkit.WorldType;
+import org.bukkit.entity.Player;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.plugin.Plugin;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map.Entry;
+import java.util.Objects;
+
+public class BukkitSetupUtils extends SetupUtils {
+
+    @Override public void updateGenerators() {
+        if (!SetupUtils.generators.isEmpty()) {
+            return;
+        }
+        String testWorld = "CheckingPlotSquaredGenerator";
+        for (Plugin plugin : Bukkit.getPluginManager().getPlugins()) {
+            try {
+                if (plugin.isEnabled()) {
+                    ChunkGenerator generator = plugin.getDefaultWorldGenerator(testWorld, "");
+                    if (generator != null) {
+                        PlotSquared.get().removePlotAreas(testWorld);
+                        String name = plugin.getDescription().getName();
+                        GeneratorWrapper<?> wrapped;
+                        if (generator instanceof GeneratorWrapper<?>) {
+                            wrapped = (GeneratorWrapper<?>) generator;
+                        } else {
+                            wrapped = new BukkitPlotGenerator(testWorld, generator);
+                        }
+                        SetupUtils.generators.put(name, wrapped);
+                    }
+                }
+            } catch (Throwable e) { // Recover from third party generator error
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override public void unload(String worldName, boolean save) {
+        World world = Bukkit.getWorld(worldName);
+        if (world == null) {
+            return;
+        }
+        World dw = Bukkit.getWorlds().get(0);
+        for (Player player : world.getPlayers()) {
+            PaperLib.teleportAsync(player,dw.getSpawnLocation());
+        }
+        if (save) {
+            for (Chunk chunk : world.getLoadedChunks()) {
+                chunk.unload(true);
+            }
+        } else {
+            for (Chunk chunk : world.getLoadedChunks()) {
+                chunk.unload(false);
+            }
+        }
+        Bukkit.unloadWorld(world, false);
+    }
+
+    @Override public String setupWorld(SetupObject object) {
+        SetupUtils.manager.updateGenerators();
+        ConfigurationNode[] steps = object.step == null ? new ConfigurationNode[0] : object.step;
+        String world = object.world;
+        int type = object.type;
+        String worldPath = "worlds." + object.world;
+        switch (type) {
+            case 2: {
+                if (object.id != null) {
+                    if (!PlotSquared.get().worlds.contains(worldPath)) {
+                        PlotSquared.get().worlds.createSection(worldPath);
+                    }
+                    ConfigurationSection worldSection =
+                        PlotSquared.get().worlds.getConfigurationSection(worldPath);
+                    String areaName = object.id + "-" + object.min + "-" + object.max;
+                    String areaPath = "areas." + areaName;
+                    if (!worldSection.contains(areaPath)) {
+                        worldSection.createSection(areaPath);
+                    }
+                    ConfigurationSection areaSection =
+                        worldSection.getConfigurationSection(areaPath);
+                    HashMap<String, Object> options = new HashMap<>();
+                    for (ConfigurationNode step : steps) {
+                        options.put(step.getConstant(), step.getValue());
+                    }
+                    options.put("generator.type", object.type);
+                    options.put("generator.terrain", object.terrain);
+                    options.put("generator.plugin", object.plotManager);
+                    if (object.setupGenerator != null && !object.setupGenerator
+                        .equals(object.plotManager)) {
+                        options.put("generator.init", object.setupGenerator);
+                    }
+                    for (Entry<String, Object> entry : options.entrySet()) {
+                        String key = entry.getKey();
+                        Object value = entry.getValue();
+                        if (worldSection.contains(key)) {
+                            Object current = worldSection.get(key);
+                            if (!Objects.equals(value, current)) {
+                                areaSection.set(key, value);
+                            }
+                        } else {
+                            worldSection.set(key, value);
+                        }
+                    }
+                }
+                GeneratorWrapper<?> gen = SetupUtils.generators.get(object.setupGenerator);
+                if (gen != null && gen.isFull()) {
+                    object.setupGenerator = null;
+                }
+                break;
+            }
+            case 1: {
+                if (!object.plotManager.endsWith(":single")) {
+                    if (!PlotSquared.get().worlds.contains(worldPath)) {
+                        PlotSquared.get().worlds.createSection(worldPath);
+                    }
+                    if (steps.length != 0) {
+                        ConfigurationSection worldSection =
+                            PlotSquared.get().worlds.getConfigurationSection(worldPath);
+                        for (ConfigurationNode step : steps) {
+                            worldSection.set(step.getConstant(), step.getValue());
+                        }
+                    }
+                    PlotSquared.get().worlds
+                        .set("worlds." + world + ".generator.type", object.type);
+                    PlotSquared.get().worlds
+                        .set("worlds." + world + ".generator.terrain", object.terrain);
+                    PlotSquared.get().worlds
+                        .set("worlds." + world + ".generator.plugin", object.plotManager);
+                    if (object.setupGenerator != null && !object.setupGenerator
+                        .equals(object.plotManager)) {
+                        PlotSquared.get().worlds
+                            .set("worlds." + world + ".generator.init", object.setupGenerator);
+                    }
+                }
+                GeneratorWrapper<?> gen = SetupUtils.generators.get(object.setupGenerator);
+                if (gen != null && gen.isFull()) {
+                    object.setupGenerator = null;
+                }
+                break;
+            }
+            case 0: {
+                if (steps.length != 0) {
+                    if (!PlotSquared.get().worlds.contains(worldPath)) {
+                        PlotSquared.get().worlds.createSection(worldPath);
+                    }
+                    ConfigurationSection worldSection =
+                        PlotSquared.get().worlds.getConfigurationSection(worldPath);
+                    for (ConfigurationNode step : steps) {
+                        worldSection.set(step.getConstant(), step.getValue());
+                    }
+                }
+                break;
+            }
+        }
+        try {
+            PlotSquared.get().worlds.save(PlotSquared.get().worldsFile);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        Plugin plugin = Bukkit.getPluginManager().getPlugin("Multiverse-Core");
+        if (object.setupGenerator != null) {
+            if (plugin != null && plugin.isEnabled()) {
+                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(),
+                    "mv create " + world + " normal -g " + object.setupGenerator);
+                setGenerator(world, object.setupGenerator);
+                if (Bukkit.getWorld(world) != null) {
+                    return world;
+                }
+            }
+            WorldCreator wc = new WorldCreator(object.world);
+            wc.generator(object.setupGenerator);
+            wc.environment(Environment.NORMAL);
+            wc.type(WorldType.FLAT);
+            Bukkit.createWorld(wc);
+            setGenerator(world, object.setupGenerator);
+        } else {
+            if (plugin != null && plugin.isEnabled()) {
+                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(),
+                    "mv create " + world + " normal");
+                if (Bukkit.getWorld(world) != null) {
+                    return world;
+                }
+            }
+            World bw =
+                Bukkit.createWorld(new WorldCreator(object.world).environment(Environment.NORMAL));
+        }
+        return object.world;
+    }
+
+    public void setGenerator(String world, String generator) {
+        if (Bukkit.getWorlds().isEmpty() || !Bukkit.getWorlds().get(0).getName().equals(world)) {
+            return;
+        }
+        File file = new File("bukkit.yml").getAbsoluteFile();
+        YamlConfiguration yml = YamlConfiguration.loadConfiguration(file);
+        yml.set("worlds." + world + ".generator", generator);
+        try {
+            yml.save(file);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override public String getGenerator(PlotArea plotArea) {
+        if (SetupUtils.generators.isEmpty()) {
+            updateGenerators();
+        }
+        World world = Bukkit.getWorld(plotArea.worldname);
+        if (world == null) {
+            return null;
+        }
+        ChunkGenerator generator = world.getGenerator();
+        if (!(generator instanceof BukkitPlotGenerator)) {
+            return null;
+        }
+        for (Entry<String, GeneratorWrapper<?>> entry : SetupUtils.generators.entrySet()) {
+            GeneratorWrapper<?> current = entry.getValue();
+            if (current.equals(generator)) {
+                return entry.getKey();
+            }
+        }
+        return null;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitTaskManager.java

@@ -0,0 +1,54 @@
+package com.github.intellectualsites.plotsquared.bukkit.util;
+
+import com.github.intellectualsites.plotsquared.bukkit.BukkitMain;
+import com.github.intellectualsites.plotsquared.plot.util.TaskManager;
+import org.bukkit.Bukkit;
+
+public class BukkitTaskManager extends TaskManager {
+
+    private final BukkitMain bukkitMain;
+
+    public BukkitTaskManager(BukkitMain bukkitMain) {
+        this.bukkitMain = bukkitMain;
+    }
+
+    @Override public int taskRepeat(Runnable runnable, int interval) {
+        return this.bukkitMain.getServer().getScheduler()
+            .scheduleSyncRepeatingTask(this.bukkitMain, runnable, interval, interval);
+    }
+
+    @SuppressWarnings("deprecation") @Override
+    public int taskRepeatAsync(Runnable runnable, int interval) {
+        return this.bukkitMain.getServer().getScheduler()
+            .scheduleAsyncRepeatingTask(this.bukkitMain, runnable, interval, interval);
+    }
+
+    @Override public void taskAsync(Runnable runnable) {
+        if (this.bukkitMain.isEnabled()) {
+            this.bukkitMain.getServer().getScheduler()
+                .runTaskAsynchronously(this.bukkitMain, runnable);
+        } else {
+            runnable.run();
+        }
+    }
+
+    @Override public void task(Runnable runnable) {
+        this.bukkitMain.getServer().getScheduler().runTask(this.bukkitMain, runnable).getTaskId();
+    }
+
+    @Override public void taskLater(Runnable runnable, int delay) {
+        this.bukkitMain.getServer().getScheduler().runTaskLater(this.bukkitMain, runnable, delay)
+            .getTaskId();
+    }
+
+    @Override public void taskLaterAsync(Runnable runnable, int delay) {
+        this.bukkitMain.getServer().getScheduler()
+            .runTaskLaterAsynchronously(this.bukkitMain, runnable, delay);
+    }
+
+    @Override public void cancelTask(int task) {
+        if (task != -1) {
+            Bukkit.getScheduler().cancelTask(task);
+        }
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitUtil.java

@@ -0,0 +1,441 @@
+package com.github.intellectualsites.plotsquared.bukkit.util;
+
+import com.github.intellectualsites.plotsquared.bukkit.object.BukkitPlayer;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.config.Captions;
+import com.github.intellectualsites.plotsquared.plot.object.Location;
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.RunnableVal;
+import com.github.intellectualsites.plotsquared.plot.object.schematic.PlotItem;
+import com.github.intellectualsites.plotsquared.plot.util.MainUtil;
+import com.github.intellectualsites.plotsquared.plot.util.MathMan;
+import com.github.intellectualsites.plotsquared.plot.util.StringComparison;
+import com.github.intellectualsites.plotsquared.plot.util.TaskManager;
+import com.github.intellectualsites.plotsquared.plot.util.UUIDHandler;
+import com.github.intellectualsites.plotsquared.plot.util.WorldUtil;
+import com.github.intellectualsites.plotsquared.plot.util.world.BlockUtil;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.bukkit.BukkitWorld;
+import com.sk89q.worldedit.regions.CuboidRegion;
+import com.sk89q.worldedit.world.biome.BiomeType;
+import com.sk89q.worldedit.world.block.BlockState;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.Sign;
+import org.bukkit.block.data.Directional;
+import org.bukkit.block.data.type.WallSign;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+@SuppressWarnings({"unused", "WeakerAccess"}) public class BukkitUtil extends WorldUtil {
+
+    private static String lastString = null;
+    private static World lastWorld = null;
+
+    private static Player lastPlayer = null;
+    private static PlotPlayer lastPlotPlayer = null;
+
+    public static void removePlayer(String player) {
+        lastPlayer = null;
+        lastPlotPlayer = null;
+    }
+
+    public static PlotPlayer getPlayer(@NonNull final OfflinePlayer op) {
+        if (op.isOnline()) {
+            return getPlayer(op.getPlayer());
+        }
+        final Player player = OfflinePlayerUtil.loadPlayer(op);
+        player.loadData();
+        return new BukkitPlayer(player, true);
+    }
+
+    /**
+     * Get a plot based on the location.
+     *
+     * @param location the location to check
+     * @return plot if found, otherwise it creates a temporary plot
+     * @see Plot
+     */
+    public static Plot getPlot(org.bukkit.Location location) {
+        if (location == null) {
+            return null;
+        }
+        return getLocation(location).getPlot();
+    }
+
+    /**
+     * Get a plot based on the player location.
+     *
+     * @param player the player to check
+     * @return plot if found, otherwise it creates a temporary plot
+     * @see #getPlot(org.bukkit.Location)
+     * @see Plot
+     */
+    public static Plot getPlot(Player player) {
+        return getPlot(player.getLocation());
+    }
+
+    /**
+     * Get home location.
+     *
+     * @param plot Plot that you want to get the location for
+     * @return plot bottom location
+     * @see Plot
+     */
+    public static org.bukkit.Location getHomeLocation(Plot plot) {
+        return BukkitUtil.getLocation(plot.getHome());
+    }
+
+    /**
+     * Get the PlotPlayer for an offline player.
+     *
+     * <p>Note that this will work if the player is offline, however not all
+     * functionality will work.
+     *
+     * @param player the player to wrap
+     * @return a {@code PlotPlayer}
+     * @see PlotPlayer#wrap(Object)
+     */
+    public static PlotPlayer wrapPlayer(OfflinePlayer player) {
+        return PlotPlayer.wrap(player);
+    }
+
+    /**
+     * Gets the PlotPlayer for a player. The PlotPlayer is usually cached and
+     * will provide useful functions relating to players.
+     *
+     * @param player the player to wrap
+     * @return a {@code PlotPlayer}
+     * @see PlotPlayer#wrap(Object)
+     */
+    public static PlotPlayer wrapPlayer(Player player) {
+        return PlotPlayer.wrap(player);
+    }
+
+    /**
+     * Gets the number of plots, which the player is able to build in.
+     *
+     * @param player player, for whom we're getting the plots
+     * @return the number of allowed plots
+     */
+    public static int getAllowedPlots(Player player) {
+        PlotPlayer plotPlayer = PlotPlayer.wrap(player);
+        return plotPlayer.getAllowedPlots();
+    }
+
+    /**
+     * Check whether or not a player is in a plot.
+     *
+     * @param player who we're checking for
+     * @return true if the player is in a plot, false if not-
+     */
+    public static boolean isInPlot(Player player) {
+        return getPlot(player) != null;
+    }
+
+    /**
+     * Gets a collection containing the players plots.
+     *
+     * @param world  Specify the world we want to select the plots from
+     * @param player Player, for whom we're getting the plots
+     * @return a set containing the players plots
+     * @see Plot
+     */
+    public static Set<Plot> getPlayerPlots(String world, Player player) {
+        if (world == null) {
+            return new HashSet<>();
+        }
+        return PlotPlayer.wrap(player).getPlots(world);
+    }
+
+    /**
+     * Send a message to a player. The message supports color codes.
+     *
+     * @param player the recipient of the message
+     * @param string the message
+     * @see MainUtil#sendMessage(PlotPlayer, String)
+     */
+    public static void sendMessage(Player player, String string) {
+        MainUtil.sendMessage(BukkitUtil.getPlayer(player), string);
+    }
+
+    /**
+     * Gets the player plot count.
+     *
+     * @param world  Specify the world we want to select the plots from
+     * @param player Player, for whom we're getting the plot count
+     * @return the number of plots the player has
+     */
+    public static int getPlayerPlotCount(String world, Player player) {
+        if (world == null) {
+            return 0;
+        }
+        return BukkitUtil.getPlayer(player).getPlotCount(world);
+    }
+
+    /**
+     * Send a message to a player.
+     *
+     * @param player  the recipient of the message
+     * @param caption the message
+     * @see MainUtil#sendMessage(com.github.intellectualsites.plotsquared.commands.CommandCaller, Captions, String...)
+     */
+    public static void sendMessage(Player player, Captions caption) {
+        MainUtil.sendMessage(BukkitUtil.getPlayer(player), caption);
+    }
+
+    public static PlotPlayer getPlayer(@NonNull final Player player) {
+        if (player == lastPlayer) {
+            return lastPlotPlayer;
+        }
+        final String name = player.getName();
+        final PlotPlayer plotPlayer = UUIDHandler.getPlayer(name);
+        if (plotPlayer != null) {
+            return plotPlayer;
+        }
+        lastPlotPlayer = new BukkitPlayer(player);
+        UUIDHandler.getPlayers().put(name, lastPlotPlayer);
+        lastPlayer = player;
+        return lastPlotPlayer;
+    }
+
+    public static Location getLocation(@NonNull final org.bukkit.Location location) {
+        return new Location(location.getWorld().getName(), MathMan.roundInt(location.getX()),
+            MathMan.roundInt(location.getY()), MathMan.roundInt(location.getZ()));
+    }
+
+    public static Location getLocationFull(@NonNull final org.bukkit.Location location) {
+      return new Location(location.getWorld().getName(), MathMan.roundInt(location.getX()),
+          MathMan.roundInt(location.getY()), MathMan.roundInt(location.getZ()),
+          location.getYaw(), location.getPitch());
+    }
+
+    public static org.bukkit.Location getLocation(@NonNull final Location location) {
+        return new org.bukkit.Location(getWorld(location.getWorld()), location.getX(),
+            location.getY(), location.getZ());
+    }
+
+    public static World getWorld(@NonNull final String string) {
+        return Bukkit.getWorld(string);
+    }
+
+    public static String getWorld(@NonNull final Entity entity) {
+        return entity.getWorld().getName();
+    }
+
+    public static List<Entity> getEntities(@NonNull final String worldName) {
+        World world = getWorld(worldName);
+        if (world != null) {
+            return world.getEntities();
+        } else {
+            return new ArrayList<>();
+        }
+    }
+
+    public static Location getLocation(@NonNull final Entity entity) {
+        final org.bukkit.Location location = entity.getLocation();
+        String world = location.getWorld().getName();
+        return new Location(world, location.getBlockX(), location.getBlockY(),
+            location.getBlockZ());
+    }
+
+    @NotNull public static Location getLocationFull(@NonNull final Entity entity) {
+        final org.bukkit.Location location = entity.getLocation();
+        return new Location(location.getWorld().getName(), MathMan.roundInt(location.getX()),
+            MathMan.roundInt(location.getY()), MathMan.roundInt(location.getZ()), location.getYaw(),
+            location.getPitch());
+    }
+
+    public static Material getMaterial(@NonNull final BlockState plotBlock) {
+        return BukkitAdapter.adapt(plotBlock.getBlockType());
+    }
+
+    @Override public boolean isBlockSame(BlockState block1, BlockState block2) {
+        if (block1.equals(block2)) {
+            return true;
+        }
+        Material mat1 = getMaterial(block1), mat2 = getMaterial(block2);
+        return mat1 == mat2;
+    }
+
+    @Override public boolean isWorld(@NonNull final String worldName) {
+        return getWorld(worldName) != null;
+    }
+
+    @Override public BiomeType getBiome(String world, int x, int z) {
+        return BukkitAdapter.adapt(getWorld(world).getBiome(x, z));
+    }
+
+    @Override public int getHighestBlock(@NonNull final String world, final int x, final int z) {
+        final World bukkitWorld = getWorld(world);
+        // Skip top and bottom block
+        int air = 1;
+        for (int y = bukkitWorld.getMaxHeight() - 1; y >= 0; y--) {
+            Block block = bukkitWorld.getBlockAt(x, y, z);
+            Material type = block.getType();
+            if (type.isSolid()) {
+                if (air > 1) {
+                    return y;
+                }
+                air = 0;
+            } else {
+                if (block.isLiquid()) {
+                    return y;
+                }
+                air++;
+            }
+        }
+        return bukkitWorld.getMaxHeight() - 1;
+    }
+
+    @Override @Nullable public String[] getSign(@NonNull final Location location) {
+        Block block = getWorld(location.getWorld()).getBlockAt(location.getX(), location.getY(), location.getZ());
+        return TaskManager.IMP.sync(new RunnableVal<String[]>() {
+            @Override public void run(String[] value) {
+                if (block.getState() instanceof Sign) {
+                    Sign sign = (Sign) block.getState();
+                    this.value = sign.getLines();
+                }
+            }
+        });
+    }
+
+    @Override public Location getSpawn(@NonNull final String world) {
+        final org.bukkit.Location temp = getWorld(world).getSpawnLocation();
+        return new Location(world, temp.getBlockX(), temp.getBlockY(), temp.getBlockZ(),
+            temp.getYaw(), temp.getPitch());
+    }
+
+    @Override public void setSpawn(@NonNull final Location location) {
+        final World world = getWorld(location.getWorld());
+        if (world != null) {
+            world.setSpawnLocation(location.getX(), location.getY(), location.getZ());
+        }
+    }
+
+    @Override public void saveWorld(@NonNull final String worldName) {
+        final World world = getWorld(worldName);
+        if (world != null) {
+            world.save();
+        }
+    }
+
+    @Override @SuppressWarnings("deprecation")
+    public void setSign(@NonNull final String worldName, final int x, final int y, final int z,
+        @NonNull final String[] lines) {
+        final World world = getWorld(worldName);
+        final Block block = world.getBlockAt(x, y, z);
+        //        block.setType(Material.AIR);
+        final Material type = block.getType();
+        if (type != Material.LEGACY_SIGN && type != Material.LEGACY_WALL_SIGN) {
+            BlockFace facing = BlockFace.EAST;
+            if (world.getBlockAt(x, y, z + 1).getType().isSolid()) {
+                facing = BlockFace.NORTH;
+            } else if (world.getBlockAt(x + 1, y, z).getType().isSolid()) {
+                facing = BlockFace.WEST;
+            } else if (world.getBlockAt(x, y, z - 1).getType().isSolid()) {
+                facing = BlockFace.SOUTH;
+            }
+            if (PlotSquared.get().IMP.getServerVersion()[1] == 13) {
+                block.setType(Material.valueOf("WALL_SIGN"), false);
+            } else {
+                block.setType(Material.valueOf("OAK_WALL_SIGN"), false);
+            }
+            if (!(block.getBlockData() instanceof WallSign)) {
+                PlotSquared.debug(block.getBlockData().getAsString());
+                throw new RuntimeException("Something went wrong generating a sign");
+            }
+            final Directional sign = (Directional) block.getBlockData();
+            sign.setFacing(facing);
+            block.setBlockData(sign, false);
+        }
+        final org.bukkit.block.BlockState blockstate = block.getState();
+        if (blockstate instanceof Sign) {
+            final Sign sign = (Sign) blockstate;
+            for (int i = 0; i < lines.length; i++) {
+                sign.setLine(i, lines[i]);
+            }
+            sign.update(true);
+        }
+    }
+
+    @Override
+    public boolean addItems(@NonNull final String worldName, @NonNull final PlotItem items) {
+        final World world = getWorld(worldName);
+        final Block block = world.getBlockAt(items.x, items.y, items.z);
+        final org.bukkit.block.BlockState state = block.getState();
+        if (state instanceof InventoryHolder) {
+            InventoryHolder holder = (InventoryHolder) state;
+            Inventory inv = holder.getInventory();
+            for (int i = 0; i < items.types.length; i++) {
+                // ItemStack item = new ItemStack(LegacyMappings.fromLegacyId(items.id[i]).getMaterial(), items.amount[i], items.data[i]);
+                ItemStack item = new ItemStack(BukkitAdapter.adapt(items.types[i]), items.amount[i]);
+                inv.addItem(item);
+            }
+            state.update(true);
+            return true;
+        }
+        return false;
+    }
+
+    @Override public boolean isBlockSolid(@NonNull final BlockState block) {
+        return block.getBlockType().getMaterial().isSolid();
+    }
+
+    @Override public String getClosestMatchingName(@NonNull final BlockState block) {
+        try {
+            return getMaterial(block).name();
+        } catch (Exception ignored) {
+            return null;
+        }
+    }
+
+    @Override @Nullable
+    public StringComparison<BlockState>.ComparisonResult getClosestBlock(String name) {
+        BlockState state = BlockUtil.get(name);
+        return new StringComparison<BlockState>().new ComparisonResult(1, state);
+    }
+
+    @Override
+    public void setBiomes(@NonNull final String worldName, @NonNull final CuboidRegion region,
+        @NonNull final BiomeType biomeType) {
+        final World world = getWorld(worldName);
+        final Biome biome = BukkitAdapter.adapt(biomeType);
+        for (int x = region.getMinimumPoint().getX(); x <= region.getMaximumPoint().getX(); x++) {
+            for (int z = region.getMinimumPoint().getZ(); z <= region.getMaximumPoint().getZ(); z++) {
+                world.setBiome(x, z, biome);
+            }
+        }
+    }
+
+    public com.sk89q.worldedit.world.World getWeWorld(String world) {
+        return new BukkitWorld(Bukkit.getWorld(world));
+    }
+
+    @Override public BlockState getBlock(@NonNull final Location location) {
+        final World world = getWorld(location.getWorld());
+        final Block block = world.getBlockAt(location.getX(), location.getY(), location.getZ());
+        return BukkitAdapter.asBlockType(block.getType()).getDefaultState();
+    }
+
+    @Override public String getMainWorld() {
+        return Bukkit.getWorlds().get(0).getName();
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitVersion.java

@@ -0,0 +1,5 @@
+package com.github.intellectualsites.plotsquared.bukkit.util;
+
+public class BukkitVersion {
+    public static int[] v1_13_2 = {1, 13, 2};
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/Metrics.java

@@ -0,0 +1,714 @@
+package com.github.intellectualsites.plotsquared.bukkit.util;
+
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.bukkit.plugin.ServicePriority;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+import javax.net.ssl.HttpsURLConnection;
+import java.io.BufferedReader;
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.UUID;
+import java.util.concurrent.Callable;
+import java.util.logging.Level;
+import java.util.zip.GZIPOutputStream;
+
+/**
+ * bStats collects some data for plugin authors.
+ * <p>
+ * Check out https://bStats.org/ to learn more about bStats!
+ */
+@SuppressWarnings({"WeakerAccess", "unused"})
+public class Metrics {
+
+    static {
+        // You can use the property to disable the check in your test environment
+        if (System.getProperty("bstats.relocatecheck") == null || !System.getProperty("bstats.relocatecheck").equals("false")) {
+            // Maven's Relocate is clever and changes strings, too. So we have to use this little "trick" ... :D
+            final String defaultPackage = new String(
+                new byte[]{'o', 'r', 'g', '.', 'b', 's', 't', 'a', 't', 's', '.', 'b', 'u', 'k', 'k', 'i', 't'});
+            final String examplePackage = new String(new byte[]{'y', 'o', 'u', 'r', '.', 'p', 'a', 'c', 'k', 'a', 'g', 'e'});
+            // We want to make sure nobody just copy & pastes the example and use the wrong package names
+
+            if (Metrics.class.getPackage().getName().equals(defaultPackage) || Metrics.class.getPackage().getName().equals(examplePackage)) {
+                throw new IllegalStateException("bStats Metrics class has not been relocated correctly!");
+            }
+        }
+    }
+
+    // The version of this bStats class
+    public static final int B_STATS_VERSION = 1;
+
+    // The url to which the data is sent
+    private static final String URL = "https://bStats.org/submitData/bukkit";
+
+    // Is bStats enabled on this server?
+    private boolean enabled;
+
+    // Should failed requests be logged?
+    private static boolean logFailedRequests;
+
+    // Should the sent data be logged?
+    private static boolean logSentData;
+
+    // Should the response text be logged?
+    private static boolean logResponseStatusText;
+
+    // The uuid of the server
+    private static String serverUUID;
+
+    // The plugin
+    private final Plugin plugin;
+
+    // The plugin id
+    private final int bstatsId;
+
+    // A list with all custom charts
+    private final List<CustomChart> charts = new ArrayList<>();
+
+    /**
+     * Class constructor.
+     *
+     * @param plugin The plugin which stats should be submitted.
+     * @param bstatsId The ID of the plugin. It can be found in the url when you open the plugin on bStats.
+     */
+    public Metrics(Plugin plugin, int bstatsId) {
+        if (plugin == null) {
+            throw new IllegalArgumentException("Plugin cannot be null!");
+        }
+        this.plugin = plugin;
+        this.bstatsId = bstatsId;
+
+        // Get the config file
+        File bStatsFolder = new File(plugin.getDataFolder().getParentFile(), "bStats");
+        File configFile = new File(bStatsFolder, "config.yml");
+        YamlConfiguration config = YamlConfiguration.loadConfiguration(configFile);
+
+        // Check if the config file exists
+        if (!config.isSet("serverUuid")) {
+
+            // Add default values
+            config.addDefault("enabled", true);
+            // Every server gets it's unique random id.
+            config.addDefault("serverUuid", UUID.randomUUID().toString());
+            // Should failed request be logged?
+            config.addDefault("logFailedRequests", false);
+            // Should the sent data be logged?
+            config.addDefault("logSentData", false);
+            // Should the response text be logged?
+            config.addDefault("logResponseStatusText", false);
+
+            // Inform the server owners about bStats
+            config.options().header(
+                "bStats collects some data for plugin authors like how many servers are using their plugins.\n" +
+                    "To honor their work, you should not disable it.\n" +
+                    "This has nearly no effect on the server performance!\n" +
+                    "Check out https://bStats.org/ to learn more :)"
+            ).copyDefaults(true);
+            try {
+                config.save(configFile);
+            } catch (IOException ignored) { }
+        }
+
+        // Load the data
+        enabled = config.getBoolean("enabled", true);
+        serverUUID = config.getString("serverUuid");
+        logFailedRequests = config.getBoolean("logFailedRequests", false);
+        logSentData = config.getBoolean("logSentData", false);
+        logResponseStatusText = config.getBoolean("logResponseStatusText", false);
+
+        if (enabled) {
+            boolean found = false;
+            // Search for all other bStats Metrics classes to see if we are the first one
+            for (Class<?> service : Bukkit.getServicesManager().getKnownServices()) {
+                try {
+                    service.getField("B_STATS_VERSION"); // Our identifier :)
+                    found = true; // We aren't the first
+                    break;
+                } catch (NoSuchFieldException ignored) { }
+            }
+            // Register our service
+            Bukkit.getServicesManager().register(Metrics.class, this, plugin, ServicePriority.Normal);
+            if (!found) {
+                // We are the first!
+                startSubmitting();
+            }
+        }
+    }
+
+    /**
+     * Checks if bStats is enabled.
+     *
+     * @return Whether bStats is enabled or not.
+     */
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    /**
+     * Adds a custom chart.
+     *
+     * @param chart The chart to add.
+     */
+    public void addCustomChart(CustomChart chart) {
+        if (chart == null) {
+            throw new IllegalArgumentException("Chart cannot be null!");
+        }
+        charts.add(chart);
+    }
+
+    /**
+     * Starts the Scheduler which submits our data every 30 minutes.
+     */
+    private void startSubmitting() {
+        final Timer timer = new Timer(true); // We use a timer cause the Bukkit scheduler is affected by server lags
+        timer.scheduleAtFixedRate(new TimerTask() {
+            @Override
+            public void run() {
+                if (!plugin.isEnabled()) { // Plugin was disabled
+                    timer.cancel();
+                    return;
+                }
+                // Nevertheless we want our code to run in the Bukkit main thread, so we have to use the Bukkit scheduler
+                // Don't be afraid! The connection to the bStats server is still async, only the stats collection is sync ;)
+                Bukkit.getScheduler().runTask(plugin, () -> submitData());
+            }
+        }, 1000 * 60 * 5, 1000 * 60 * 30);
+        // Submit the data every 30 minutes, first time after 5 minutes to give other plugins enough time to start
+        // WARNING: Changing the frequency has no effect but your plugin WILL be blocked/deleted!
+        // WARNING: Just don't do it!
+    }
+
+    /**
+     * Gets the plugin specific data.
+     * This method is called using Reflection.
+     *
+     * @return The plugin specific data.
+     */
+    public JSONObject getPluginData() {
+        JSONObject data = new JSONObject();
+
+        String pluginName = plugin.getDescription().getName();
+        String pluginVersion = plugin.getDescription().getVersion();
+
+        data.put("pluginName", pluginName); // Append the name of the plugin
+        data.put("id", bstatsId); // Append the id of the plugin
+        data.put("pluginVersion", pluginVersion); // Append the version of the plugin
+        JSONArray customCharts = new JSONArray();
+        for (CustomChart customChart : charts) {
+            // Add the data of the custom charts
+            JSONObject chart = customChart.getRequestJsonObject();
+            if (chart == null) { // If the chart is null, we skip it
+                continue;
+            }
+            customCharts.add(chart);
+        }
+        data.put("customCharts", customCharts);
+
+        return data;
+    }
+
+    /**
+     * Gets the server specific data.
+     *
+     * @return The server specific data.
+     */
+    private JSONObject getServerData() {
+        // Minecraft specific data
+        int playerAmount;
+        try {
+            // Around MC 1.8 the return type was changed to a collection from an array,
+            // This fixes java.lang.NoSuchMethodError: org.bukkit.Bukkit.getOnlinePlayers()Ljava/util/Collection;
+            Method onlinePlayersMethod = Class.forName("org.bukkit.Server").getMethod("getOnlinePlayers");
+            playerAmount = onlinePlayersMethod.getReturnType().equals(Collection.class)
+                ? ((Collection<?>) onlinePlayersMethod.invoke(Bukkit.getServer())).size()
+                : ((Player[]) onlinePlayersMethod.invoke(Bukkit.getServer())).length;
+        } catch (Exception e) {
+            playerAmount = Bukkit.getOnlinePlayers().size(); // Just use the new method if the Reflection failed
+        }
+        int onlineMode = Bukkit.getOnlineMode() ? 1 : 0;
+        String bukkitVersion = Bukkit.getVersion();
+
+        // OS/Java specific data
+        String javaVersion = System.getProperty("java.version");
+        String osName = System.getProperty("os.name");
+        String osArch = System.getProperty("os.arch");
+        String osVersion = System.getProperty("os.version");
+        int coreCount = Runtime.getRuntime().availableProcessors();
+
+        JSONObject data = new JSONObject();
+
+        data.put("serverUUID", serverUUID);
+
+        data.put("playerAmount", playerAmount);
+        data.put("onlineMode", onlineMode);
+        data.put("bukkitVersion", bukkitVersion);
+
+        data.put("javaVersion", javaVersion);
+        data.put("osName", osName);
+        data.put("osArch", osArch);
+        data.put("osVersion", osVersion);
+        data.put("coreCount", coreCount);
+
+        return data;
+    }
+
+    /**
+     * Collects the data and sends it afterwards.
+     */
+    private void submitData() {
+        final JSONObject data = getServerData();
+
+        JSONArray pluginData = new JSONArray();
+        // Search for all other bStats Metrics classes to get their plugin data
+        for (Class<?> service : Bukkit.getServicesManager().getKnownServices()) {
+            try {
+                service.getField("B_STATS_VERSION"); // Our identifier :)
+
+                for (RegisteredServiceProvider<?> provider : Bukkit.getServicesManager().getRegistrations(service)) {
+                    try {
+                        pluginData.add(provider.getService().getMethod("getPluginData").invoke(provider.getProvider()));
+                    } catch (NullPointerException | NoSuchMethodException | IllegalAccessException | InvocationTargetException ignored) { }
+                }
+            } catch (NoSuchFieldException ignored) { }
+        }
+
+        data.put("plugins", pluginData);
+
+        // Create a new thread for the connection to the bStats server
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    // Send the data
+                    sendData(plugin, data);
+                } catch (Exception e) {
+                    // Something went wrong! :(
+                    if (logFailedRequests) {
+                        plugin.getLogger().log(Level.WARNING, "Could not submit plugin stats of " + plugin.getName(), e);
+                    }
+                }
+            }
+        }).start();
+    }
+
+    /**
+     * Sends the data to the bStats server.
+     *
+     * @param plugin Any plugin. It's just used to get a logger instance.
+     * @param data The data to send.
+     * @throws Exception If the request failed.
+     */
+    private static void sendData(Plugin plugin, JSONObject data) throws Exception {
+        if (data == null) {
+            throw new IllegalArgumentException("Data cannot be null!");
+        }
+        if (Bukkit.isPrimaryThread()) {
+            throw new IllegalAccessException("This method must not be called from the main thread!");
+        }
+        if (logSentData) {
+            plugin.getLogger().info("Sending data to bStats: " + data.toString());
+        }
+        HttpsURLConnection connection = (HttpsURLConnection) new URL(URL).openConnection();
+
+        // Compress the data to save bandwidth
+        byte[] compressedData = compress(data.toString());
+
+        // Add headers
+        connection.setRequestMethod("POST");
+        connection.addRequestProperty("Accept", "application/json");
+        connection.addRequestProperty("Connection", "close");
+        connection.addRequestProperty("Content-Encoding", "gzip"); // We gzip our request
+        connection.addRequestProperty("Content-Length", String.valueOf(compressedData.length));
+        connection.setRequestProperty("Content-Type", "application/json"); // We send our data in JSON format
+        connection.setRequestProperty("User-Agent", "MC-Server/" + B_STATS_VERSION);
+
+        // Send data
+        connection.setDoOutput(true);
+        DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream());
+        outputStream.write(compressedData);
+        outputStream.flush();
+        outputStream.close();
+
+        InputStream inputStream = connection.getInputStream();
+        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
+
+        StringBuilder builder = new StringBuilder();
+        String line;
+        while ((line = bufferedReader.readLine()) != null) {
+            builder.append(line);
+        }
+        bufferedReader.close();
+        if (logResponseStatusText) {
+            plugin.getLogger().info("Sent data to bStats and received response: " + builder.toString());
+        }
+    }
+
+    /**
+     * Gzips the given String.
+     *
+     * @param str The string to gzip.
+     * @return The gzipped String.
+     * @throws IOException If the compression failed.
+     */
+    private static byte[] compress(final String str) throws IOException {
+        if (str == null) {
+            return null;
+        }
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        GZIPOutputStream gzip = new GZIPOutputStream(outputStream);
+        gzip.write(str.getBytes(StandardCharsets.UTF_8));
+        gzip.close();
+        return outputStream.toByteArray();
+    }
+
+    /**
+     * Represents a custom chart.
+     */
+    public static abstract class CustomChart {
+
+        // The id of the chart
+        final String chartId;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         */
+        CustomChart(String chartId) {
+            if (chartId == null || chartId.isEmpty()) {
+                throw new IllegalArgumentException("ChartId cannot be null or empty!");
+            }
+            this.chartId = chartId;
+        }
+
+        private JSONObject getRequestJsonObject() {
+            JSONObject chart = new JSONObject();
+            chart.put("chartId", chartId);
+            try {
+                JSONObject data = getChartData();
+                if (data == null) {
+                    // If the data is null we don't send the chart.
+                    return null;
+                }
+                chart.put("data", data);
+            } catch (Throwable t) {
+                if (logFailedRequests) {
+                    Bukkit.getLogger().log(Level.WARNING, "Failed to get data for custom chart with id " + chartId, t);
+                }
+                return null;
+            }
+            return chart;
+        }
+
+        protected abstract JSONObject getChartData() throws Exception;
+
+    }
+
+    /**
+     * Represents a custom simple pie.
+     */
+    public static class SimplePie extends CustomChart {
+
+        private final Callable<String> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public SimplePie(String chartId, Callable<String> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JSONObject getChartData() throws Exception {
+            JSONObject data = new JSONObject();
+            String value = callable.call();
+            if (value == null || value.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            data.put("value", value);
+            return data;
+        }
+    }
+
+    /**
+     * Represents a custom advanced pie.
+     */
+    public static class AdvancedPie extends CustomChart {
+
+        private final Callable<Map<String, Integer>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public AdvancedPie(String chartId, Callable<Map<String, Integer>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JSONObject getChartData() throws Exception {
+            JSONObject data = new JSONObject();
+            JSONObject values = new JSONObject();
+            Map<String, Integer> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            boolean allSkipped = true;
+            for (Map.Entry<String, Integer> entry : map.entrySet()) {
+                if (entry.getValue() == 0) {
+                    continue; // Skip this invalid
+                }
+                allSkipped = false;
+                values.put(entry.getKey(), entry.getValue());
+            }
+            if (allSkipped) {
+                // Null = skip the chart
+                return null;
+            }
+            data.put("values", values);
+            return data;
+        }
+    }
+
+    /**
+     * Represents a custom drilldown pie.
+     */
+    public static class DrilldownPie extends CustomChart {
+
+        private final Callable<Map<String, Map<String, Integer>>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public DrilldownPie(String chartId, Callable<Map<String, Map<String, Integer>>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        public JSONObject getChartData() throws Exception {
+            JSONObject data = new JSONObject();
+            JSONObject values = new JSONObject();
+            Map<String, Map<String, Integer>> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            boolean reallyAllSkipped = true;
+            for (Map.Entry<String, Map<String, Integer>> entryValues : map.entrySet()) {
+                JSONObject value = new JSONObject();
+                boolean allSkipped = true;
+                for (Map.Entry<String, Integer> valueEntry : map.get(entryValues.getKey()).entrySet()) {
+                    value.put(valueEntry.getKey(), valueEntry.getValue());
+                    allSkipped = false;
+                }
+                if (!allSkipped) {
+                    reallyAllSkipped = false;
+                    values.put(entryValues.getKey(), value);
+                }
+            }
+            if (reallyAllSkipped) {
+                // Null = skip the chart
+                return null;
+            }
+            data.put("values", values);
+            return data;
+        }
+    }
+
+    /**
+     * Represents a custom single line chart.
+     */
+    public static class SingleLineChart extends CustomChart {
+
+        private final Callable<Integer> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public SingleLineChart(String chartId, Callable<Integer> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JSONObject getChartData() throws Exception {
+            JSONObject data = new JSONObject();
+            int value = callable.call();
+            if (value == 0) {
+                // Null = skip the chart
+                return null;
+            }
+            data.put("value", value);
+            return data;
+        }
+
+    }
+
+    /**
+     * Represents a custom multi line chart.
+     */
+    public static class MultiLineChart extends CustomChart {
+
+        private final Callable<Map<String, Integer>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public MultiLineChart(String chartId, Callable<Map<String, Integer>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JSONObject getChartData() throws Exception {
+            JSONObject data = new JSONObject();
+            JSONObject values = new JSONObject();
+            Map<String, Integer> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            boolean allSkipped = true;
+            for (Map.Entry<String, Integer> entry : map.entrySet()) {
+                if (entry.getValue() == 0) {
+                    continue; // Skip this invalid
+                }
+                allSkipped = false;
+                values.put(entry.getKey(), entry.getValue());
+            }
+            if (allSkipped) {
+                // Null = skip the chart
+                return null;
+            }
+            data.put("values", values);
+            return data;
+        }
+
+    }
+
+    /**
+     * Represents a custom simple bar chart.
+     */
+    public static class SimpleBarChart extends CustomChart {
+
+        private final Callable<Map<String, Integer>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public SimpleBarChart(String chartId, Callable<Map<String, Integer>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JSONObject getChartData() throws Exception {
+            JSONObject data = new JSONObject();
+            JSONObject values = new JSONObject();
+            Map<String, Integer> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            for (Map.Entry<String, Integer> entry : map.entrySet()) {
+                JSONArray categoryValues = new JSONArray();
+                categoryValues.add(entry.getValue());
+                values.put(entry.getKey(), categoryValues);
+            }
+            data.put("values", values);
+            return data;
+        }
+
+    }
+
+    /**
+     * Represents a custom advanced bar chart.
+     */
+    public static class AdvancedBarChart extends CustomChart {
+
+        private final Callable<Map<String, int[]>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public AdvancedBarChart(String chartId, Callable<Map<String, int[]>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JSONObject getChartData() throws Exception {
+            JSONObject data = new JSONObject();
+            JSONObject values = new JSONObject();
+            Map<String, int[]> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            boolean allSkipped = true;
+            for (Map.Entry<String, int[]> entry : map.entrySet()) {
+                if (entry.getValue().length == 0) {
+                    continue; // Skip this invalid
+                }
+                allSkipped = false;
+                JSONArray categoryValues = new JSONArray();
+                for (int categoryValue : entry.getValue()) {
+                    categoryValues.add(categoryValue);
+                }
+                values.put(entry.getKey(), categoryValues);
+            }
+            if (allSkipped) {
+                // Null = skip the chart
+                return null;
+            }
+            data.put("values", values);
+            return data;
+        }
+    }
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/OfflinePlayerUtil.java

@@ -0,0 +1,87 @@
+package com.github.intellectualsites.plotsquared.bukkit.util;
+
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.UUID;
+
+import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.callConstructor;
+import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.callMethod;
+import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.getCbClass;
+import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.getNmsClass;
+import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.getUtilClass;
+import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.makeConstructor;
+import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.makeMethod;
+
+public class OfflinePlayerUtil {
+
+    public static Player loadPlayer(OfflinePlayer player) {
+        if (player == null) {
+            return null;
+        }
+        if (player instanceof Player) {
+            return (Player) player;
+        }
+        return loadPlayer(player.getUniqueId(), player.getName());
+    }
+
+    private static Player loadPlayer(UUID id, String name) {
+        Object server = getMinecraftServer();
+        Object interactManager = newPlayerInteractManager();
+        Object worldServer = getWorldServer();
+        Object profile = newGameProfile(id, name);
+        Class<?> entityPlayerClass = getNmsClass("EntityPlayer");
+        Constructor entityPlayerConstructor =
+            makeConstructor(entityPlayerClass, getNmsClass("MinecraftServer"),
+                getNmsClass("WorldServer"), getUtilClass("com.mojang.authlib.GameProfile"),
+                getNmsClass("PlayerInteractManager"));
+        Object entityPlayer =
+            callConstructor(entityPlayerConstructor, server, worldServer, profile, interactManager);
+        return (Player) getBukkitEntity(entityPlayer);
+    }
+
+    private static Object newGameProfile(UUID id, String name) {
+        Class<?> gameProfileClass = getUtilClass("com.mojang.authlib.GameProfile");
+        if (gameProfileClass == null) { //Before uuids
+            return name;
+        }
+        Constructor gameProfileConstructor =
+            makeConstructor(gameProfileClass, UUID.class, String.class);
+        if (gameProfileConstructor == null) { //Version has string constructor
+            gameProfileConstructor = makeConstructor(gameProfileClass, String.class, String.class);
+            return callConstructor(gameProfileConstructor, id.toString(), name);
+        } else { //Version has uuid constructor
+            return callConstructor(gameProfileConstructor, id, name);
+        }
+    }
+
+    private static Object newPlayerInteractManager() {
+        Object worldServer = getWorldServer();
+        Class<?> playerInteractClass = getNmsClass("PlayerInteractManager");
+        Class<?> worldClass = getNmsClass("World");
+        Constructor c = makeConstructor(playerInteractClass, worldClass);
+        return callConstructor(c, worldServer);
+    }
+
+    private static Object getWorldServer() {
+        Object server = getMinecraftServer();
+        Class<?> minecraftServerClass = getNmsClass("MinecraftServer");
+        Method getWorldServer = makeMethod(minecraftServerClass, "getWorldServer", int.class);
+        return callMethod(getWorldServer, server, 0);
+    }
+
+    //NMS Utils
+
+    private static Object getMinecraftServer() {
+        return callMethod(makeMethod(getCbClass("CraftServer"), "getServer"), Bukkit.getServer());
+    }
+
+    private static Entity getBukkitEntity(Object o) {
+        Method getBukkitEntity = makeMethod(o.getClass(), "getBukkitEntity");
+        return callMethod(getBukkitEntity, o);
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/SendChunk.java

@@ -0,0 +1,142 @@
+package com.github.intellectualsites.plotsquared.bukkit.util;
+
+import com.github.intellectualsites.plotsquared.bukkit.object.BukkitPlayer;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.object.Location;
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.RefClass;
+import com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.RefConstructor;
+import com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.RefField;
+import com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.RefMethod;
+import com.github.intellectualsites.plotsquared.plot.util.TaskManager;
+import com.github.intellectualsites.plotsquared.plot.util.UUIDHandler;
+import com.sk89q.worldedit.math.BlockVector2;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map.Entry;
+
+import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.getRefClass;
+
+/**
+ * An utility that can be used to send chunks, rather than using bukkit code
+ * to do so (uses heavy NMS).
+ */
+public class SendChunk {
+
+    private final RefMethod methodGetHandlePlayer;
+    private final RefMethod methodGetHandleChunk;
+    private final RefConstructor mapChunk;
+    private final RefField connection;
+    private final RefMethod send;
+    private final RefMethod methodInitLighting;
+
+    /**
+     * Constructor.
+     */
+    public SendChunk() throws ClassNotFoundException, NoSuchMethodException, NoSuchFieldException {
+        RefClass classCraftPlayer = getRefClass("{cb}.entity.CraftPlayer");
+        this.methodGetHandlePlayer = classCraftPlayer.getMethod("getHandle");
+        RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
+        this.methodGetHandleChunk = classCraftChunk.getMethod("getHandle");
+        RefClass classChunk = getRefClass("{nms}.Chunk");
+        this.methodInitLighting = classChunk.getMethod("initLighting");
+        RefClass classMapChunk = getRefClass("{nms}.PacketPlayOutMapChunk");
+        this.mapChunk = classMapChunk.getConstructor(classChunk.getRealClass(), int.class);
+        RefClass classEntityPlayer = getRefClass("{nms}.EntityPlayer");
+        this.connection = classEntityPlayer.getField("playerConnection");
+        RefClass classPacket = getRefClass("{nms}.Packet");
+        RefClass classConnection = getRefClass("{nms}.PlayerConnection");
+        this.send = classConnection.getMethod("sendPacket", classPacket.getRealClass());
+    }
+
+    public void sendChunk(Collection<Chunk> input) {
+        HashSet<Chunk> chunks = new HashSet<>(input);
+        HashMap<String, ArrayList<Chunk>> map = new HashMap<>();
+        int view = Bukkit.getServer().getViewDistance();
+        for (Chunk chunk : chunks) {
+            String world = chunk.getWorld().getName();
+            ArrayList<Chunk> list = map.computeIfAbsent(world, k -> new ArrayList<>());
+            list.add(chunk);
+            Object c = this.methodGetHandleChunk.of(chunk).call();
+            this.methodInitLighting.of(c).call();
+        }
+        for (Entry<String, PlotPlayer> entry : UUIDHandler.getPlayers().entrySet()) {
+            PlotPlayer pp = entry.getValue();
+            Plot plot = pp.getCurrentPlot();
+            Location location = null;
+            String world;
+            if (plot != null) {
+                world = plot.getWorldName();
+            } else {
+                location = pp.getLocation();
+                world = location.getWorld();
+            }
+            ArrayList<Chunk> list = map.get(world);
+            if (list == null) {
+                continue;
+            }
+            if (location == null) {
+                location = pp.getLocation();
+            }
+            int chunkX = location.getX() >> 4;
+            int chunkZ = location.getZ() >> 4;
+            Player player = ((BukkitPlayer) pp).player;
+            Object entity = this.methodGetHandlePlayer.of(player).call();
+
+            for (Chunk chunk : list) {
+                int dx = Math.abs(chunkX - chunk.getX());
+                int dz = Math.abs(chunkZ - chunk.getZ());
+                if ((dx > view) || (dz > view)) {
+                    continue;
+                }
+                Object c = this.methodGetHandleChunk.of(chunk).call();
+                chunks.remove(chunk);
+                Object con = this.connection.of(entity).get();
+                Object packet = null;
+                try {
+                    packet = this.mapChunk.create(c, 65535);
+                } catch (Exception ignored) {
+                }
+                if (packet == null) {
+                    PlotSquared.debug("Error with PacketPlayOutMapChunk reflection.");
+                }
+                this.send.of(con).call(packet);
+            }
+        }
+        for (final Chunk chunk : chunks) {
+            TaskManager.runTask(() -> {
+                try {
+                    chunk.unload(true);
+                } catch (Throwable ignored) {
+                    String worldName = chunk.getWorld().getName();
+                    PlotSquared.debug(
+                        "$4Could not save chunk: " + worldName + ';' + chunk.getX() + ";" + chunk
+                            .getZ());
+                    PlotSquared.debug("$3 - $4File may be open in another process (e.g. MCEdit)");
+                    PlotSquared.debug("$3 - $4" + worldName + "/level.dat or " + worldName
+                        + "/level_old.dat may be corrupt (try repairing or removing these)");
+                }
+            });
+        }
+    }
+
+    public void sendChunk(String worldName, Collection<BlockVector2> chunkLocations) {
+        World myWorld = Bukkit.getWorld(worldName);
+        ArrayList<Chunk> chunks = new ArrayList<>();
+        for (BlockVector2 loc : chunkLocations) {
+            if (myWorld.isChunkLoaded(loc.getX(), loc.getZ())) {
+                PaperLib.getChunkAtAsync(myWorld, loc.getX(), loc.getZ()).thenAccept(chunks::add);
+            }
+        }
+        sendChunk(chunks);
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/SetGenCB.java

@@ -0,0 +1,52 @@
+package com.github.intellectualsites.plotsquared.bukkit.util;
+
+import com.github.intellectualsites.plotsquared.bukkit.generator.BukkitAugmentedGenerator;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.generator.GeneratorWrapper;
+import com.github.intellectualsites.plotsquared.plot.util.SetupUtils;
+import org.bukkit.World;
+import org.bukkit.generator.ChunkGenerator;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+
+public class SetGenCB {
+
+    public static void setGenerator(World world) throws Exception {
+        SetupUtils.manager.updateGenerators();
+        PlotSquared.get().removePlotAreas(world.getName());
+        ChunkGenerator gen = world.getGenerator();
+        if (gen == null) {
+            return;
+        }
+        String name = gen.getClass().getCanonicalName();
+        boolean set = false;
+        for (GeneratorWrapper<?> wrapper : SetupUtils.generators.values()) {
+            ChunkGenerator newGen = (ChunkGenerator) wrapper.getPlatformGenerator();
+            if (newGen == null) {
+                newGen = (ChunkGenerator) wrapper;
+            }
+            if (newGen.getClass().getCanonicalName().equals(name)) {
+                // set generator
+                Field generator = world.getClass().getDeclaredField("generator");
+                Field populators = world.getClass().getDeclaredField("populators");
+                generator.setAccessible(true);
+                populators.setAccessible(true);
+                // Set populators (just in case)
+                populators.set(world, new ArrayList<>());
+                // Set generator
+                generator.set(world, newGen);
+                populators.set(world, newGen.getDefaultPopulators(world));
+                // end
+                set = true;
+                break;
+            }
+        }
+        if (!set) {
+            world.getPopulators()
+                .removeIf(blockPopulator -> blockPopulator instanceof BukkitAugmentedGenerator);
+        }
+        PlotSquared.get()
+            .loadWorld(world.getName(), PlotSquared.get().IMP.getGenerator(world.getName(), null));
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue.java

@@ -0,0 +1,147 @@
+package com.github.intellectualsites.plotsquared.bukkit.util.block;
+
+import com.github.intellectualsites.plotsquared.bukkit.object.BukkitBlockUtil;
+import com.github.intellectualsites.plotsquared.bukkit.object.schematic.StateWrapper;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.util.MainUtil;
+import com.github.intellectualsites.plotsquared.plot.util.block.BasicLocalBlockQueue;
+import com.github.intellectualsites.plotsquared.plot.util.world.BlockUtil;
+import com.sk89q.jnbt.CompoundTag;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.world.biome.BiomeType;
+import com.sk89q.worldedit.world.block.BaseBlock;
+import com.sk89q.worldedit.world.block.BlockState;
+import io.papermc.lib.PaperLib;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+
+import java.util.concurrent.ExecutionException;
+
+public class BukkitLocalQueue extends BasicLocalBlockQueue {
+
+    public BukkitLocalQueue(String world) {
+        super(world);
+    }
+
+    @Override public LocalChunk getLocalChunk(int x, int z) {
+        return new BasicLocalChunk(this, x, z) {
+            // Custom stuff?
+        };
+    }
+
+    @Override public void optimize() {
+
+    }
+
+    @Override public BlockState getBlock(int x, int y, int z) {
+        World worldObj = Bukkit.getWorld(getWorld());
+        if (worldObj != null) {
+            Block block = worldObj.getBlockAt(x, y, z);
+            return BukkitBlockUtil.get(block);
+        } else {
+            return BlockUtil.get(0, 0);
+        }
+    }
+
+    @Override public void refreshChunk(int x, int z) {
+        World worldObj = Bukkit.getWorld(getWorld());
+        if (worldObj != null) {
+            worldObj.refreshChunk(x, z);
+        } else {
+            PlotSquared.debug("Error Refreshing Chunk");
+        }
+    }
+
+    @Override public void fixChunkLighting(int x, int z) {
+        // Do nothing
+    }
+
+    @Override public final void regenChunk(int x, int z) {
+        World worldObj = Bukkit.getWorld(getWorld());
+        if (worldObj != null) {
+            worldObj.regenerateChunk(x, z);
+        } else {
+            PlotSquared.debug("Error Regenerating Chunk");
+        }
+    }
+
+    @Override public final void setComponents(LocalChunk lc)
+        throws ExecutionException, InterruptedException {
+        setBaseBlocks(lc);
+    }
+
+    public void setBaseBlocks(LocalChunk localChunk) {
+        World worldObj = Bukkit.getWorld(getWorld());
+        if (worldObj == null) {
+            throw new NullPointerException("World cannot be null.");
+        }
+        PaperLib.getChunkAtAsync(worldObj, localChunk.getX(), localChunk.getZ(), true)
+            .thenAccept(chunk -> {
+                for (int layer = 0; layer < localChunk.baseblocks.length; layer++) {
+                    BaseBlock[] blocksLayer = localChunk.baseblocks[layer];
+                    if (blocksLayer != null) {
+                        for (int j = 0; j < blocksLayer.length; j++) {
+                            if (blocksLayer[j] != null) {
+                                BaseBlock block = blocksLayer[j];
+                                int x = MainUtil.x_loc[layer][j];
+                                int y = MainUtil.y_loc[layer][j];
+                                int z = MainUtil.z_loc[layer][j];
+
+                                BlockData blockData = BukkitAdapter.adapt(block);
+
+                                Block existing = chunk.getBlock(x, y, z);
+                                if (BukkitBlockUtil.get(existing).equals(block) && existing
+                                    .getBlockData().matches(blockData)) {
+                                    continue;
+                                }
+
+                                existing.setType(BukkitAdapter.adapt(block.getBlockType()), false);
+                                existing.setBlockData(blockData, false);
+                                if (block.hasNbtData()) {
+                                    CompoundTag tag = block.getNbtData();
+                                    StateWrapper sw = new StateWrapper(tag);
+
+                                    sw.restoreTag(worldObj.getName(), existing.getX(),
+                                        existing.getY(), existing.getZ());
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+    }
+
+    private void setMaterial(@NonNull final BlockState plotBlock, @NonNull final Block block) {
+        Material material = BukkitAdapter.adapt(plotBlock.getBlockType());
+        block.setType(material, false);
+    }
+
+    private boolean equals(@NonNull final BlockState plotBlock, @NonNull final Block block) {
+        return plotBlock.equals(BukkitBlockUtil.get(block));
+    }
+
+    public void setBiomes(LocalChunk lc) {
+        if (lc.biomes != null) {
+            World worldObj = Bukkit.getWorld(getWorld());
+            int bx = lc.getX() << 4;
+            int bz = lc.getX() << 4;
+            for (int x = 0; x < lc.biomes.length; x++) {
+                BiomeType[] biomes2 = lc.biomes[x];
+                if (biomes2 != null) {
+                    for (BiomeType biomeStr : biomes2) {
+                        if (biomeStr != null) {
+                            Biome biome = BukkitAdapter.adapt(biomeStr);
+                            worldObj.setBiome(bx, bz, biome);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/GenChunk.java

@@ -0,0 +1,191 @@
+package com.github.intellectualsites.plotsquared.bukkit.util.block;
+
+import com.github.intellectualsites.plotsquared.bukkit.object.BukkitBlockUtil;
+import com.github.intellectualsites.plotsquared.bukkit.util.BukkitUtil;
+import com.github.intellectualsites.plotsquared.plot.object.ChunkWrapper;
+import com.github.intellectualsites.plotsquared.plot.object.Location;
+import com.github.intellectualsites.plotsquared.plot.util.MainUtil;
+import com.github.intellectualsites.plotsquared.plot.util.block.ScopedLocalBlockQueue;
+import com.github.intellectualsites.plotsquared.plot.util.world.PatternUtil;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.function.pattern.Pattern;
+import com.sk89q.worldedit.world.biome.BiomeType;
+import com.sk89q.worldedit.world.block.BaseBlock;
+import com.sk89q.worldedit.world.block.BlockState;
+import com.sk89q.worldedit.world.block.BlockTypes;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.generator.ChunkGenerator.BiomeGrid;
+import org.bukkit.generator.ChunkGenerator.ChunkData;
+
+import java.util.Arrays;
+
+public class GenChunk extends ScopedLocalBlockQueue {
+
+    public final Biome[] biomes;
+    public BlockState[][] result;
+    public BiomeGrid biomeGrid;
+    public Chunk chunk;
+    public String world;
+    public int chunkX;
+    public int chunkZ;
+    @Getter @Setter private ChunkData chunkData = null;
+
+    public GenChunk() {
+        super(null, new Location(null, 0, 0, 0), new Location(null, 15, 255, 15));
+        this.biomes = Biome.values();
+    }
+
+    public Chunk getChunk() {
+        if (chunk == null) {
+            World worldObj = BukkitUtil.getWorld(world);
+            if (worldObj != null) {
+                this.chunk = worldObj.getChunkAt(chunkX, chunkZ);
+            }
+        }
+        return chunk;
+    }
+
+    public void setChunk(Chunk chunk) {
+        this.chunk = chunk;
+    }
+
+    public void setChunk(ChunkWrapper wrap) {
+        chunk = null;
+        world = wrap.world;
+        chunkX = wrap.x;
+        chunkZ = wrap.z;
+    }
+
+    @Override public void fillBiome(BiomeType biomeType) {
+        if (biomeGrid == null) {
+            return;
+        }
+        Biome biome = BukkitAdapter.adapt(biomeType);
+        for (int x = 0; x < 16; x++) {
+            for (int z = 0; z < 16; z++) {
+                this.biomeGrid.setBiome(x, z, biome);
+            }
+        }
+    }
+
+    @Override public void setCuboid(Location pos1, Location pos2, BlockState block) {
+        if (result != null && pos1.getX() == 0 && pos1.getZ() == 0 && pos2.getX() == 15
+            && pos2.getZ() == 15) {
+            for (int y = pos1.getY(); y <= pos2.getY(); y++) {
+                int layer = y >> 4;
+                BlockState[] data = result[layer];
+                if (data == null) {
+                    result[layer] = data = new BlockState[4096];
+                }
+                int start = y << 8;
+                int end = start + 256;
+                Arrays.fill(data, start, end, block);
+            }
+        }
+        int minX = Math.min(pos1.getX(), pos2.getX());
+        int minY = Math.min(pos1.getY(), pos2.getY());
+        int minZ = Math.min(pos1.getZ(), pos2.getZ());
+        int maxX = Math.max(pos1.getX(), pos2.getX());
+        int maxY = Math.max(pos1.getY(), pos2.getY());
+        int maxZ = Math.max(pos1.getZ(), pos2.getZ());
+        chunkData.setRegion(minX, minY, minZ, maxX + 1, maxY + 1, maxZ + 1, BukkitAdapter.adapt(block));
+    }
+
+    @Override public boolean setBiome(int x, int z, BiomeType biomeType) {
+        return setBiome(x, z, BukkitAdapter.adapt(biomeType));
+    }
+
+    public boolean setBiome(int x, int z, Biome biome) {
+        if (this.biomeGrid != null) {
+            this.biomeGrid.setBiome(x, z, biome);
+            return true;
+        }
+        return false;
+    }
+
+    @Override public boolean setBlock(int x, int y, int z, Pattern pattern) {
+        return setBlock(x, y, z, PatternUtil.apply(pattern, x, y, z));
+    }
+
+    @Override public boolean setBlock(int x, int y, int z, BlockState id) {
+        if (this.result == null) {
+            this.chunkData.setBlock(x, y, z, BukkitAdapter.adapt(id));
+            return true;
+        }
+        this.chunkData.setBlock(x, y, z, BukkitAdapter.adapt(id));
+        this.storeCache(x, y, z, id);
+        return true;
+    }
+
+    private void storeCache(final int x, final int y, final int z, final BlockState id) {
+        int i = MainUtil.CACHE_I[y][x][z];
+        BlockState[] v = this.result[i];
+        if (v == null) {
+            this.result[i] = v = new BlockState[4096];
+        }
+        int j = MainUtil.CACHE_J[y][x][z];
+        v[j] = id;
+    }
+
+    @Override public boolean setBlock(int x, int y, int z, BaseBlock id) {
+        if (this.result == null) {
+            this.chunkData.setBlock(x, y, z, BukkitAdapter.adapt(id));
+            return true;
+        }
+        this.chunkData.setBlock(x, y, z, BukkitAdapter.adapt(id));
+        this.storeCache(x, y, z, id.toImmutableState());
+        return true;
+    }
+
+    @Override public BlockState getBlock(int x, int y, int z) {
+        int i = MainUtil.CACHE_I[y][x][z];
+        if (result == null) {
+            return BukkitBlockUtil.get(chunkData.getType(x, y, z));
+        }
+        BlockState[] array = result[i];
+        if (array == null) {
+            return BlockTypes.AIR.getDefaultState();
+        }
+        int j = MainUtil.CACHE_J[y][x][z];
+        return array[j];
+    }
+
+    public int getX() {
+        return chunk == null ? chunkX : chunk.getX();
+    }
+
+    public int getZ() {
+        return chunk == null ? chunkZ : chunk.getZ();
+    }
+
+    @Override public String getWorld() {
+        return chunk == null ? world : chunk.getWorld().getName();
+    }
+
+    @Override public Location getMax() {
+        return new Location(getWorld(), 15 + (getX() << 4), 255, 15 + (getZ() << 4));
+    }
+
+    @Override public Location getMin() {
+        return new Location(getWorld(), getX() << 4, 0, getZ() << 4);
+    }
+
+    public GenChunk clone() {
+        GenChunk toReturn = new GenChunk();
+        if (this.result != null) {
+            for (int i = 0; i < this.result.length; i++) {
+                BlockState[] matrix = this.result[i];
+                if (matrix != null) {
+                    toReturn.result[i] = new BlockState[matrix.length];
+                    System.arraycopy(matrix, 0, toReturn.result[i], 0, matrix.length);
+                }
+            }
+        }
+        toReturn.chunkData = this.chunkData;
+        return toReturn;
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/uuid/DatFileFilter.java

@@ -0,0 +1,11 @@
+package com.github.intellectualsites.plotsquared.bukkit.uuid;
+
+import java.io.File;
+import java.io.FilenameFilter;
+
+public class DatFileFilter implements FilenameFilter {
+
+    @Override public boolean accept(File dir, String name) {
+        return name.endsWith(".dat");
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/uuid/DefaultUUIDWrapper.java

@@ -0,0 +1,41 @@
+package com.github.intellectualsites.plotsquared.bukkit.uuid;
+
+import com.github.intellectualsites.plotsquared.bukkit.object.BukkitOfflinePlayer;
+import com.github.intellectualsites.plotsquared.bukkit.object.BukkitPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.OfflinePlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.uuid.UUIDWrapper;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.UUID;
+
+public class DefaultUUIDWrapper extends UUIDWrapper {
+
+    @NotNull @Override public UUID getUUID(PlotPlayer player) {
+        return ((BukkitPlayer) player).player.getUniqueId();
+    }
+
+    @Override public UUID getUUID(OfflinePlotPlayer player) {
+        return player.getUUID();
+    }
+
+    @Override public OfflinePlotPlayer getOfflinePlayer(UUID uuid) {
+        return new BukkitOfflinePlayer(Bukkit.getOfflinePlayer(uuid));
+    }
+
+    @Override public UUID getUUID(String name) {
+        return Bukkit.getOfflinePlayer(name).getUniqueId();
+    }
+
+    @Override public OfflinePlotPlayer[] getOfflinePlayers() {
+        OfflinePlayer[] ops = Bukkit.getOfflinePlayers();
+        return Arrays.stream(ops).map(BukkitOfflinePlayer::new).toArray(BukkitOfflinePlayer[]::new);
+    }
+
+    @Override public OfflinePlotPlayer getOfflinePlayer(String name) {
+        return new BukkitOfflinePlayer(Bukkit.getOfflinePlayer(name));
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/uuid/FileUUIDHandler.java

@@ -0,0 +1,265 @@
+package com.github.intellectualsites.plotsquared.bukkit.uuid;
+
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.config.Captions;
+import com.github.intellectualsites.plotsquared.plot.config.Settings;
+import com.github.intellectualsites.plotsquared.plot.object.OfflinePlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.RunnableVal;
+import com.github.intellectualsites.plotsquared.plot.object.StringWrapper;
+import com.github.intellectualsites.plotsquared.plot.util.StringMan;
+import com.github.intellectualsites.plotsquared.plot.util.TaskManager;
+import com.github.intellectualsites.plotsquared.plot.util.UUIDHandler;
+import com.github.intellectualsites.plotsquared.plot.util.UUIDHandlerImplementation;
+import com.github.intellectualsites.plotsquared.plot.util.expiry.ExpireManager;
+import com.github.intellectualsites.plotsquared.plot.uuid.UUIDWrapper;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.Sets;
+import com.sk89q.jnbt.CompoundTag;
+import com.sk89q.jnbt.NBTInputStream;
+import com.sk89q.jnbt.Tag;
+import java.io.BufferedInputStream;
+import java.io.FileNotFoundException;
+import java.util.Map;
+import java.util.zip.GZIPInputStream;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.UUID;
+
+public class FileUUIDHandler extends UUIDHandlerImplementation {
+
+    public FileUUIDHandler(UUIDWrapper wrapper) {
+        super(wrapper);
+    }
+
+    @Override public boolean startCaching(Runnable whenDone) {
+        return super.startCaching(whenDone) && cache(whenDone);
+    }
+
+    private Tag readTag(File file) throws IOException {
+        // Don't chain the creation of the GZIP stream and the NBT stream, because their
+        // constructors may throw an IOException.
+        try (BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(file));
+            GZIPInputStream gzipInputStream = new GZIPInputStream(inputStream);
+            NBTInputStream nbtInputStream = new NBTInputStream(gzipInputStream)) {
+            return nbtInputStream.readNamedTag().getTag();
+        }
+    }
+
+    public boolean cache(final Runnable whenDone) {
+        final File container = Bukkit.getWorldContainer();
+        List<World> worlds = Bukkit.getWorlds();
+        final String world;
+        if (worlds.isEmpty()) {
+            world = "world";
+        } else {
+            world = worlds.get(0).getName();
+        }
+        TaskManager.runTaskAsync(() -> {
+            PlotSquared.debug(Captions.PREFIX + "Starting player data caching for: " + world);
+            File uuidFile = new File(PlotSquared.get().IMP.getDirectory(), "uuids.txt");
+            if (uuidFile.exists()) {
+                try {
+                    List<String> lines =
+                        Files.readAllLines(uuidFile.toPath(), StandardCharsets.UTF_8);
+                    for (String line : lines) {
+                        try {
+                            line = line.trim();
+                            if (line.isEmpty()) {
+                                continue;
+                            }
+                            line = line.replaceAll("[\\|][0-9]+[\\|][0-9]+[\\|]", "");
+                            String[] split = line.split("\\|");
+                            String name = split[0];
+                            if (name.isEmpty() || (name.length() > 16) || !StringMan
+                                .isAlphanumericUnd(name)) {
+                                continue;
+                            }
+                            UUID uuid = FileUUIDHandler.this.uuidWrapper.getUUID(name);
+                            if (uuid == null) {
+                                continue;
+                            }
+                            UUIDHandler.add(new StringWrapper(name), uuid);
+                        } catch (Exception e2) {
+                            e2.printStackTrace();
+                        }
+                    }
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            HashBiMap<StringWrapper, UUID> toAdd = HashBiMap.create(new HashMap<>());
+            if (Settings.UUID.NATIVE_UUID_PROVIDER) {
+                HashSet<UUID> all = UUIDHandler.getAllUUIDS();
+                PlotSquared.debug("Fast mode UUID caching enabled!");
+                File playerDataFolder = new File(container, world + File.separator + "playerdata");
+                String[] dat = playerDataFolder.list(new DatFileFilter());
+                boolean check = all.isEmpty();
+                if (dat != null) {
+                    for (String current : dat) {
+                        String s = current.replaceAll(".dat$", "");
+                        try {
+                            UUID uuid = UUID.fromString(s);
+                            if (check || all.remove(uuid)) {
+                                File file = new File(playerDataFolder, current);
+                                CompoundTag compound = (CompoundTag) readTag(file);
+                                if (!compound.containsKey("bukkit")) {
+                                    PlotSquared.debug("ERROR: Player data (" + uuid.toString()
+                                        + ".dat) does not contain the the key \"bukkit\"");
+                                } else {
+                                    Map<String, Tag> compoundMap = compound.getValue();
+                                    CompoundTag bukkit = (CompoundTag) compoundMap.get("bukkit");
+                                    Map<String, Tag> bukkitMap = bukkit.getValue();
+                                    String name =
+                                        (String) bukkitMap.get("lastKnownName").getValue();
+                                    long last = (long) bukkitMap.get("lastPlayed").getValue();
+                                    long first = (long) bukkitMap.get("firstPlayed").getValue();
+                                    if (ExpireManager.IMP != null) {
+                                        ExpireManager.IMP.storeDate(uuid, last);
+                                        ExpireManager.IMP.storeAccountAge(uuid, last - first);
+                                    }
+                                    toAdd.put(new StringWrapper(name), uuid);
+                                }
+                            }
+                        } catch (Exception e) {
+                            e.printStackTrace();
+                            PlotSquared.debug(Captions.PREFIX + "Invalid playerdata: " + current);
+                        }
+                    }
+                }
+                add(toAdd);
+                if (all.isEmpty()) {
+                    if (whenDone != null) {
+                        whenDone.run();
+                    }
+                    return;
+                } else {
+                    PlotSquared.debug(
+                        "Failed to cache: " + all.size() + " uuids - slowly processing all files");
+                }
+            }
+            HashSet<String> worlds1 = Sets.newHashSet(world, "world");
+            HashSet<UUID> uuids = new HashSet<>();
+            HashSet<String> names = new HashSet<>();
+            File playerDataFolder = null;
+            for (String worldName : worlds1) {
+                // Getting UUIDs
+                playerDataFolder = new File(container, worldName + File.separator + "playerdata");
+                String[] dat = playerDataFolder.list(new DatFileFilter());
+                if ((dat != null) && (dat.length != 0)) {
+                    for (String current : dat) {
+                        String s = current.replaceAll(".dat$", "");
+                        try {
+                            UUID uuid = UUID.fromString(s);
+                            uuids.add(uuid);
+                        } catch (Exception ignored) {
+                            PlotSquared.debug(Captions.PREFIX + "Invalid PlayerData: " + current);
+                        }
+                    }
+                    break;
+                }
+                // Getting names
+                File playersFolder = new File(worldName + File.separator + "players");
+                dat = playersFolder.list(new DatFileFilter());
+                if ((dat != null) && (dat.length != 0)) {
+                    for (String current : dat) {
+                        names.add(current.replaceAll(".dat$", ""));
+                    }
+                    break;
+                }
+            }
+            for (UUID uuid : uuids) {
+                try {
+                    File file =
+                        new File(playerDataFolder + File.separator + uuid.toString() + ".dat");
+                    if (!file.exists()) {
+                        continue;
+                    }
+                    CompoundTag compound = (CompoundTag) readTag(file);
+                    if (!compound.containsKey("bukkit")) {
+                        PlotSquared.debug("ERROR: Player data (" + uuid.toString()
+                            + ".dat) does not contain the the key \"bukkit\"");
+                    } else {
+                        Map<String, Tag> compoundMap = compound.getValue();
+                        CompoundTag bukkit = (CompoundTag) compoundMap.get("bukkit");
+                        Map<String, Tag> bukkitMap = bukkit.getValue();
+                        String name = (String) bukkitMap.get("lastKnownName").getValue();
+                        StringWrapper wrap = new StringWrapper(name);
+                        if (!toAdd.containsKey(wrap)) {
+                            long last = (long) bukkitMap.get("lastPlayed").getValue();
+                            long first = (long) bukkitMap.get("firstPlayed").getValue();
+                            if (Settings.UUID.OFFLINE) {
+                                if (Settings.UUID.FORCE_LOWERCASE && !name.toLowerCase()
+                                    .equals(name)) {
+                                    uuid = FileUUIDHandler.this.uuidWrapper.getUUID(name);
+                                } else {
+                                    long most = (long) compoundMap.get("UUIDMost").getValue();
+                                    long least = (long) compoundMap.get("UUIDLeast").getValue();
+                                    uuid = new UUID(most, least);
+                                }
+                            }
+                            if (ExpireManager.IMP != null) {
+                                ExpireManager.IMP.storeDate(uuid, last);
+                                ExpireManager.IMP.storeAccountAge(uuid, last - first);
+                            }
+                            toAdd.put(wrap, uuid);
+                        }
+                    }
+                } catch (Exception ignored) {
+                    PlotSquared.debug(
+                        Captions.PREFIX + "&6Invalid PlayerData: " + uuid.toString() + ".dat");
+                }
+            }
+            for (String name : names) {
+                UUID uuid = FileUUIDHandler.this.uuidWrapper.getUUID(name);
+                StringWrapper nameWrap = new StringWrapper(name);
+                toAdd.put(nameWrap, uuid);
+            }
+
+            if (getUUIDMap().isEmpty()) {
+                for (OfflinePlotPlayer offlinePlotPlayer : FileUUIDHandler.this.uuidWrapper
+                    .getOfflinePlayers()) {
+                    long last = offlinePlotPlayer.getLastPlayed();
+                    if (last != 0) {
+                        String name = offlinePlotPlayer.getName();
+                        StringWrapper wrap = new StringWrapper(name);
+                        if (!toAdd.containsKey(wrap)) {
+                            UUID uuid = FileUUIDHandler.this.uuidWrapper.getUUID(offlinePlotPlayer);
+                            if (toAdd.containsValue(uuid)) {
+                                StringWrapper duplicate = toAdd.inverse().get(uuid);
+                                PlotSquared.debug(
+                                    "The UUID: " + uuid.toString() + " is already mapped to "
+                                        + duplicate
+                                        + "\n It cannot be added to the Map with a key of " + wrap);
+                            }
+                            toAdd.putIfAbsent(wrap, uuid);
+                            if (ExpireManager.IMP != null) {
+                                ExpireManager.IMP.storeDate(uuid, last);
+                            }
+                        }
+                    }
+                }
+            }
+            add(toAdd);
+            if (whenDone != null) {
+                whenDone.run();
+            }
+        });
+        return true;
+    }
+
+    @Override public void fetchUUID(final String name, final RunnableVal<UUID> ifFetch) {
+        TaskManager.runTaskAsync(() -> {
+            ifFetch.value = FileUUIDHandler.this.uuidWrapper.getUUID(name);
+            TaskManager.runTask(ifFetch);
+        });
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/uuid/LowerOfflineUUIDWrapper.java

@@ -0,0 +1,33 @@
+package com.github.intellectualsites.plotsquared.bukkit.uuid;
+
+import com.github.intellectualsites.plotsquared.plot.object.OfflinePlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.google.common.base.Charsets;
+import org.bukkit.OfflinePlayer;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+import java.util.UUID;
+
+public class LowerOfflineUUIDWrapper extends OfflineUUIDWrapper {
+
+    @NotNull @Override public UUID getUUID(PlotPlayer player) {
+        return UUID.nameUUIDFromBytes(("OfflinePlayer:" + player.getName().toLowerCase()).getBytes(Charsets.UTF_8));
+    }
+
+    @Override public UUID getUUID(OfflinePlotPlayer player) {
+        return UUID.nameUUIDFromBytes(
+            ("OfflinePlayer:" + player.getName().toLowerCase()).getBytes(Charsets.UTF_8));
+    }
+
+    @Override public UUID getUUID(OfflinePlayer player) {
+        return UUID.nameUUIDFromBytes(
+            ("OfflinePlayer:" + Objects.requireNonNull(player.getName()).toLowerCase()).getBytes(Charsets.UTF_8));
+    }
+
+    @Override public UUID getUUID(String name) {
+        return UUID
+            .nameUUIDFromBytes(("OfflinePlayer:" + name.toLowerCase()).getBytes(Charsets.UTF_8));
+    }
+
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/uuid/OfflineUUIDWrapper.java

@@ -0,0 +1,105 @@
+package com.github.intellectualsites.plotsquared.bukkit.uuid;
+
+import com.github.intellectualsites.plotsquared.bukkit.object.BukkitOfflinePlayer;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.object.OfflinePlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.StringWrapper;
+import com.github.intellectualsites.plotsquared.plot.util.UUIDHandler;
+import com.github.intellectualsites.plotsquared.plot.uuid.UUIDWrapper;
+import com.google.common.base.Charsets;
+import com.google.common.collect.BiMap;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.UUID;
+
+public class OfflineUUIDWrapper extends UUIDWrapper {
+
+    private final Object[] arg = new Object[0];
+    private Method getOnline = null;
+
+    public OfflineUUIDWrapper() {
+        try {
+            this.getOnline = Server.class.getMethod("getOnlinePlayers");
+        } catch (NoSuchMethodException | SecurityException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @NotNull @Override public UUID getUUID(PlotPlayer player) {
+        return UUID.nameUUIDFromBytes(("OfflinePlayer:" + player.getName()).getBytes(Charsets.UTF_8));
+    }
+
+    @Override public UUID getUUID(OfflinePlotPlayer player) {
+        return UUID
+            .nameUUIDFromBytes(("OfflinePlayer:" + player.getName()).getBytes(Charsets.UTF_8));
+    }
+
+    public UUID getUUID(OfflinePlayer player) {
+        return UUID
+            .nameUUIDFromBytes(("OfflinePlayer:" + player.getName()).getBytes(Charsets.UTF_8));
+    }
+
+    @Override public OfflinePlotPlayer getOfflinePlayer(UUID uuid) {
+        BiMap<UUID, StringWrapper> map = UUIDHandler.getUuidMap().inverse();
+        String name = null;
+        if (map.containsKey(uuid)) {
+            name = map.get(uuid).value;
+        }
+        if (name != null) {
+            OfflinePlayer op = Bukkit.getOfflinePlayer(name);
+            if (op.hasPlayedBefore()) {
+                return new BukkitOfflinePlayer(op);
+            }
+        }
+        for (OfflinePlayer player : Bukkit.getOfflinePlayers()) {
+            if (getUUID(player).equals(uuid)) {
+                return new BukkitOfflinePlayer(player);
+            }
+        }
+        return null;
+    }
+
+    public Player[] getOnlinePlayers() {
+        if (this.getOnline == null) {
+            Collection<? extends Player> onlinePlayers = Bukkit.getOnlinePlayers();
+            return onlinePlayers.toArray(new Player[0]);
+        }
+        try {
+            Object players = this.getOnline.invoke(Bukkit.getServer(), this.arg);
+            if (players instanceof Player[]) {
+                return (Player[]) players;
+            } else {
+                @SuppressWarnings("unchecked") Collection<? extends Player> p =
+                    (Collection<? extends Player>) players;
+                return p.toArray(new Player[0]);
+            }
+        } catch (IllegalAccessException | InvocationTargetException | IllegalArgumentException ignored) {
+            PlotSquared.debug("Failed to resolve online players");
+            this.getOnline = null;
+            Collection<? extends Player> onlinePlayers = Bukkit.getOnlinePlayers();
+            return onlinePlayers.toArray(new Player[0]);
+        }
+    }
+
+    @Override public UUID getUUID(String name) {
+        return UUID.nameUUIDFromBytes(("OfflinePlayer:" + name).getBytes(Charsets.UTF_8));
+    }
+
+    @Override public OfflinePlotPlayer[] getOfflinePlayers() {
+        OfflinePlayer[] ops = Bukkit.getOfflinePlayers();
+        return Arrays.stream(ops).map(BukkitOfflinePlayer::new).toArray(BukkitOfflinePlayer[]::new);
+    }
+
+    @Override public OfflinePlotPlayer getOfflinePlayer(String name) {
+        return new BukkitOfflinePlayer(Bukkit.getOfflinePlayer(name));
+    }
+}

Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/uuid/SQLUUIDHandler.java

@@ -0,0 +1,245 @@
+package com.github.intellectualsites.plotsquared.bukkit.uuid;
+
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.config.Captions;
+import com.github.intellectualsites.plotsquared.plot.config.Settings;
+import com.github.intellectualsites.plotsquared.plot.database.SQLite;
+import com.github.intellectualsites.plotsquared.plot.object.RunnableVal;
+import com.github.intellectualsites.plotsquared.plot.object.StringWrapper;
+import com.github.intellectualsites.plotsquared.plot.util.MainUtil;
+import com.github.intellectualsites.plotsquared.plot.util.TaskManager;
+import com.github.intellectualsites.plotsquared.plot.util.UUIDHandler;
+import com.github.intellectualsites.plotsquared.plot.util.UUIDHandlerImplementation;
+import com.github.intellectualsites.plotsquared.plot.uuid.UUIDWrapper;
+import com.google.common.collect.HashBiMap;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayDeque;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+public class SQLUUIDHandler extends UUIDHandlerImplementation {
+
+    final int MAX_REQUESTS = 500;
+    private final String PROFILE_URL =
+        "https://sessionserver.mojang.com/session/minecraft/profile/";
+    private final JSONParser jsonParser = new JSONParser();
+    private final SQLite sqlite;
+
+    public SQLUUIDHandler(UUIDWrapper wrapper) {
+        super(wrapper);
+        this.sqlite =
+            new SQLite(MainUtil.getFile(PlotSquared.get().IMP.getDirectory(), "usercache.db"));
+        try {
+            this.sqlite.openConnection();
+        } catch (ClassNotFoundException | SQLException e) {
+            e.printStackTrace();
+        }
+
+        try (PreparedStatement stmt = getConnection().prepareStatement(
+            "CREATE TABLE IF NOT EXISTS `usercache` (uuid VARCHAR(32) NOT NULL, username VARCHAR(32) NOT NULL, PRIMARY KEY (uuid, username))")) {
+            stmt.execute();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        startCaching(null);
+    }
+
+    private Connection getConnection() {
+        synchronized (this.sqlite) {
+            return this.sqlite.getConnection();
+        }
+    }
+
+    @Override public boolean startCaching(final Runnable whenDone) {
+        if (!super.startCaching(whenDone)) {
+            return false;
+        }
+        TaskManager.runTaskAsync(() -> {
+            try {
+                HashBiMap<StringWrapper, UUID> toAdd = HashBiMap.create(new HashMap<>());
+                try (PreparedStatement statement = getConnection()
+                    .prepareStatement("SELECT `uuid`, `username` FROM `usercache`");
+                    ResultSet resultSet = statement.executeQuery()) {
+                    while (resultSet.next()) {
+                        StringWrapper username = new StringWrapper(resultSet.getString("username"));
+                        UUID uuid = UUID.fromString(resultSet.getString("uuid"));
+                        toAdd.put(new StringWrapper(username.value), uuid);
+                    }
+                }
+                add(toAdd);
+                // This should be called as long as there are some unknown plots
+                final ArrayDeque<UUID> toFetch = new ArrayDeque<>();
+                for (UUID u : UUIDHandler.getAllUUIDS()) {
+                    if (!uuidExists(u)) {
+                        toFetch.add(u);
+                    }
+                }
+                if (toFetch.isEmpty()) {
+                    if (whenDone != null) {
+                        whenDone.run();
+                    }
+                    return;
+                }
+                FileUUIDHandler fileHandler = new FileUUIDHandler(SQLUUIDHandler.this.uuidWrapper);
+                fileHandler.startCaching(() -> {
+                    // If the file based UUID handler didn't cache it, then we can't cache offline mode
+                    // Also, trying to cache based on files again, is useless as that's what the file based uuid cacher does
+                    if (Settings.UUID.OFFLINE) {
+                        if (whenDone != null) {
+                            whenDone.run();
+                        }
+                        return;
+                    }
+
+                    TaskManager.runTaskAsync(() -> {
+                        while (!toFetch.isEmpty()) {
+                            try {
+                                for (int i = 0; i < Math.min(MAX_REQUESTS, toFetch.size()); i++) {
+                                    UUID uuid = toFetch.pop();
+                                    HttpURLConnection connection = (HttpURLConnection) new URL(
+                                        SQLUUIDHandler.this.PROFILE_URL + uuid.toString()
+                                            .replace("-", "")).openConnection();
+                                    try (InputStream con = connection.getInputStream()) {
+                                        InputStreamReader reader = new InputStreamReader(con);
+                                        JSONObject response =
+                                            (JSONObject) SQLUUIDHandler.this.jsonParser
+                                                .parse(reader);
+                                        String name = (String) response.get("name");
+                                        if (name != null) {
+                                            add(new StringWrapper(name), uuid);
+                                        }
+                                    }
+                                    connection.disconnect();
+                                }
+                            } catch (IOException | ParseException e) {
+                                PlotSquared.debug(
+                                    "Invalid response from Mojang: Some UUIDs will be cached later. (`unknown` until then or player joins)");
+                            }
+                            try {
+                                //Mojang allows requests every 10 minutes according to https://wiki.vg/Mojang_API
+                                //15 Minutes is chosen here since system timers are not always precise
+                                //and it should provide enough time where Mojang won't block requests.
+                                TimeUnit.MINUTES.sleep(15);
+                            } catch (InterruptedException e) {
+                                e.printStackTrace();
+                                break;
+                            }
+                        }
+                        if (whenDone != null) {
+                            whenDone.run();
+                        }
+                    });
+                });
+            } catch (SQLException e) {
+                throw new SQLUUIDHandlerException("Couldn't select :s", e);
+            }
+        });
+        return true;
+    }
+
+    @Override public void fetchUUID(final String name, final RunnableVal<UUID> ifFetch) {
+        PlotSquared.debug(Captions.PREFIX + "UUID for '" + name
+            + "' was null. We'll cache this from the Mojang servers!");
+        if (ifFetch == null) {
+            return;
+        }
+        TaskManager.runTaskAsync(() -> {
+            try {
+                URL url = new URL(SQLUUIDHandler.this.PROFILE_URL);
+                HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+                connection.setRequestMethod("POST");
+                connection.setRequestProperty("Content-Type", "application/json");
+                connection.setUseCaches(false);
+                connection.setDoInput(true);
+                connection.setDoOutput(true);
+                String body = JSONArray.toJSONString(Collections.singletonList(name));
+                OutputStream stream = connection.getOutputStream();
+                stream.write(body.getBytes());
+                stream.flush();
+                stream.close();
+                JSONArray array = (JSONArray) SQLUUIDHandler.this.jsonParser
+                    .parse(new InputStreamReader(connection.getInputStream()));
+                JSONObject jsonProfile = (JSONObject) array.get(0);
+                String id = (String) jsonProfile.get("id");
+                String name1 = (String) jsonProfile.get("name");
+                ifFetch.value = UUID.fromString(
+                    id.substring(0, 8) + '-' + id.substring(8, 12) + '-' + id.substring(12, 16)
+                        + '-' + id.substring(16, 20) + '-' + id.substring(20, 32));
+            } catch (IOException | ParseException e) {
+                e.printStackTrace();
+            }
+            TaskManager.runTask(ifFetch);
+        });
+    }
+
+    @Override public void handleShutdown() {
+        super.handleShutdown();
+        try {
+            getConnection().close();
+        } catch (SQLException e) {
+            throw new SQLUUIDHandlerException("Couldn't close database connection", e);
+        }
+    }
+
+    /**
+     * This is useful for name changes
+     */
+    @Override public void rename(final UUID uuid, final StringWrapper name) {
+        super.rename(uuid, name);
+        TaskManager.runTaskAsync(() -> {
+            try (PreparedStatement statement = getConnection()
+                .prepareStatement("UPDATE usercache SET `username`=? WHERE `uuid`=?")) {
+                statement.setString(1, name.value);
+                statement.setString(2, uuid.toString());
+                statement.execute();
+                PlotSquared.debug(
+                    Captions.PREFIX + "Name change for '" + uuid + "' to '" + name.value + '\'');
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        });
+    }
+
+    @Override public boolean add(final StringWrapper name, final UUID uuid) {
+        // Ignoring duplicates
+        if (super.add(name, uuid)) {
+            TaskManager.runTaskAsync(() -> {
+                try (PreparedStatement statement = getConnection()
+                    .prepareStatement("REPLACE INTO usercache (`uuid`, `username`) VALUES(?, ?)")) {
+                    statement.setString(1, uuid.toString());
+                    statement.setString(2, name.toString());
+                    statement.execute();
+                    PlotSquared
+                        .debug(Captions.PREFIX + "&cAdded '&6" + uuid + "&c' - '&6" + name + "&c'");
+                } catch (SQLException e) {
+                    e.printStackTrace();
+                }
+            });
+            return true;
+        }
+        return false;
+    }
+
+    private static class SQLUUIDHandlerException extends RuntimeException {
+
+        SQLUUIDHandlerException(String s, Throwable c) {
+            super("SQLUUIDHandler caused an exception: " + s, c);
+        }
+    }
+}

Bukkit/src/main/resources/plugin.yml

@@ -0,0 +1,314 @@
+name: ${name}
+main: com.github.intellectualsites.plotsquared.bukkit.BukkitMain
+api-version: "1.13"
+version: "${version}"
+load: STARTUP
+description: "Easy, yet powerful Plot World generation and management."
+authors: [Citymonstret, Empire92, MattBDev, dordsor21]
+website: https://github.com/IntellectualSites/
+softdepend: [BarAPI, CameraAPI, Vault]
+loadbefore: [MultiWorld, Multiverse-Core]
+depend: [WorldEdit]
+database: false
+commands:
+  plots:
+    description: Plot command.
+    aliases: [p,plot,ps,plotsquared,p2,2,plotme]
+    permission: plots.use
+    permission-message: "You are lacking the permission node 'plots.use'"
+permissions:
+  plots.use:
+    default: true
+  plots.teleport.delay.bypass:
+    default: op
+  plots.permpack.basicflags:
+    default: op
+    children:
+      plots.set.flag: true
+      plots.flag: true
+      plots.flag.add: true
+      plots.flag.remove: true
+      plots.flag.list: true
+      plots.flag.info: true
+      plots.set.flag.titles.*: true
+      plots.set.flag.greeting.*: true
+      plots.set.flag.farewell.*: true
+      plots.set.flag.notify-enter.*: true
+      plots.set.flag.notify-leave.*: true
+      plots.set.flag.feed.*: true
+      plots.set.flag.heal.*: true
+      plots.set.flag.invincible.*: true
+      plots.set.flag.instabreak.*: true
+      plots.set.flag.fly.*: true
+      plots.set.flag.gamemode: true
+      plots.set.flag.gamemode.creative: true
+      plots.set.flag.gamemode.survival: true
+      plots.set.flag.gamemode.adventure: true
+      plots.set.flag.time.*: true
+      plots.set.flag.weather.*: true
+      plots.set.flag.music.*: true
+      plots.set.flag.disable-physics.*: true
+      plots.set.flag.pve.*: true
+      plots.set.flag.pvp.*: true
+      plots.set.flag.explosion.*: true
+      plots.set.flag.hostile-interact.*: true
+      plots.set.flag.hostile-attack.*: true
+      plots.set.flag.player-interact.*: true
+      plots.set.flag.animal-interact.*: true
+      plots.set.flag.animal-attack.*: true
+      plots.set.flag.tamed-interact.*: true
+      plots.set.flag.tamed-attack.*: true
+      plots.set.flag.misc-interact.*: true
+      plots.set.flag.hanging-place.*: true
+      plots.set.flag.hanging-break.*: true
+      plots.set.flag.vehicle-use.*: true
+      plots.set.flag.vehicle-place.*: true
+      plots.set.flag.vehicle-break.*: true
+      plots.set.flag.place.*: true
+      plots.set.flag.break.*: true
+      plots.set.flag.use.*: true
+      plots.set.flag.forcefield.*: true
+      plots.set.flag.price.*: true
+      plots.set.flag.no-worldedit.*: true
+  plots.permpack.basicinbox:
+    default: op
+    children:
+      comments.notifications.enabled: true
+      plots.inbox.read.public: true
+      plots.inbox.modify.public: true
+      plots.inbox.write.public: true
+      plots.inbox.read.report: true
+      plots.inbox.write.report: true
+      plots.inbox.read.owner: true
+      plots.inbox.modify.owner: true
+      plots.inbox.write.owner: true
+      plots.comment: true
+      plots.inbox: true
+  plots.permpack.wilderness:
+    default: op
+    children:
+      plots.admin.interact.unowned: true
+      plots.admin.destroy.unowned: true
+      plots.admin.build.unowned: true
+      plots.projectile.unowned: true
+      plots.admin.vehicle.break.unowned: true
+      plots.admin.pve.unowned: true
+  plots.permpack.basic:
+    default: op
+    children:
+      plots.use: true
+      plots.info: true
+      plots.claim: true
+      plots.auto: true
+      plots.home: true
+      plots.clear: true
+      plots.delete: true
+      plots.music: true
+      plots.list: true
+      plots.list.mine: true
+      plots.list.shared: true
+      plots.list.world: true
+      plots.list.all: true
+      plots.list.forsale: true
+      plots.list.unowned: true
+      plots.list.unknown: true
+      plots.set: true
+      plots.visit: true
+      plots.visit.owned: true
+      plots.visit.shared: true
+      plots.set.flag: true
+      plots.flag.add: true
+      plots.flag.remove: true
+      plots.flag.list: true
+      plots.flag.info: true
+      plots.flag: true
+      plots.buy: true
+      plots.chat: true
+      plots.confirm: true
+      plots.toggle: true
+      plots.toggle.titles: true
+      plots.toggle.chat: true
+      plots.toggle.time: true
+      plots.set.biome: true
+      plots.set.home: true
+      plots.set.alias: true
+      plots.alias.set: true
+      plots.alias.remove: true
+      plots.set.description: true
+      plots.description: true
+      plots.alias: true
+      plots.merge: true
+      plots.merge.other: true
+      plots.merge.4: true
+      plots.unlink: true
+      plots.denied: true
+      plots.add: true
+      plots.trust: true
+      plots.deny: true
+      plots.remove: true
+      plots.untrust: true
+      plots.undeny: true
+      plots.kick: true
+      plots.download: true
+      plots.save: true
+      plots.done: true
+      plots.continue: true
+      plots.middle: true
+  plots.worldedit.bypass:
+    default: false
+  plots.gamemode.bypass:
+    default: op
+  plots.confirm.bypass:
+    default: false
+  plotme.use:
+    description: Gives default user commands
+    children:
+      plots.permpack.basic: true
+      plots.plot.1: true
+  plotme.admin:
+    description: Gives default administrator commands
+    children:
+      plots.admin: true
+  plotme.use.middle:
+    children:
+      plots.middle: true
+  plotme.use.buy:
+    children:
+      plots.buy: true
+  plotme.use.sell:
+    children:
+      plots.set: true
+      plots.flag: true
+      plots.set.flag: true
+      plots.set.price.*: true
+  plotme.use.dispose:
+    children:
+      plots.delete: true
+  plotme.use.done:
+    children:
+      plots.done: true
+  plotme.use.claim:
+    children:
+      plots.claim: true
+  plotme.use.auto:
+    children:
+      plots.auto: true
+  plotme.use.reset:
+    children:
+      plots.delete: true
+  plotme.use.home:
+    children:
+      plots.home: true
+  plotme.use.info:
+    children:
+      plots.info: true
+  plotme.use.biome:
+    children:
+      plots.set: true
+      plots.set.biome: true
+  plotme.use.clear:
+    children:
+      plots.clear: true
+  plotme.use.list:
+    children:
+      plots.list: true
+      plots.list.forsale: true
+      plots.list.mine: true
+      plots.list.shared: true
+  plotme.use.add:
+    children:
+      plots.add: true
+      plots.trust: true
+      plots.add.everyone: true
+      plots.trust.everyone: true
+  plotme.use.deny:
+    children:
+      plots.deny: true
+      plots.deny.everyone: true
+  plotme.use.remove:
+    children:
+      plots.remove: true
+  plotme.use.undeny:
+    children:
+      plots.remove: true
+  plotme.use.protect:
+    children:
+      plots.set: true
+      plots.flag: true
+      plots.set.flag: true
+      plots.set.keep.*: true
+  plotme.use.nameplot:
+    children:
+      plots.set.alias: true
+      plots.alias.set: true
+      plots.alias.remove: true
+  plotme.limit.*:
+    children:
+      plots.plot.*: true
+  plotme.limit.1:
+    children:
+      plots.plot.1: true
+  plotme.limit.5:
+    children:
+      plots.plot.5: true
+  plotme.limit.10:
+    children:
+      plots.plot.10: true
+  plotme.admin.clear:
+    children:
+      plots.admin.command.clear: true
+  plotme.admin.reset:
+    children:
+      plots.admin.command.delete: true
+  plotme.admin.add:
+    children:
+      plots.admin.command.add: true
+  plotme.admin.deny:
+    children:
+      plots.admin.command.deny: true
+  plotme.admin.remove:
+    children:
+      plots.admin.command.remove: true
+  plotme.admin.undeny:
+    children:
+      plots.admin.command.remove: true
+  plotme.admin.bypassdeny:
+    children:
+      plots.admin.entry.denied: true
+  plotme.admin.setowner:
+    children:
+      plots.admin.command.setowner: true
+  plotme.admin.move:
+    children:
+      plots.admin.command.move: true
+  plotme.admin.weanywhere:
+    children:
+      plots.worldedit.bypass: true
+  plotme.admin.list:
+    children:
+      plots.list.world: true
+      plots.list.world.*: true
+      plots.list.top: true
+      plots.list.all: true
+      plots.list.unowned: true
+      plots.list.unknown: true
+      plots.list.player: true
+      plots.list.done: true
+      plots.list.expired: true
+      plots.list.fuzzy: true
+      plots.list.area: true
+  plotme.admin.dispose:
+    children:
+      plots.admin.command.delete: true
+  plotme.admin.done:
+    children:
+      plots.admin.command.done: true
+  plotme.admin.expired:
+    children:
+      plots.list.expired: true
+  plotme.admin.buildanywhere:
+    children:
+      plots.admin.vehicle.*: true
+      plots.admin.interact.*: true
+      plots.admin.build.*: true
+      plots.admin.destroy.*: true

CONTRIBUTING.md

@@ -0,0 +1,9 @@
+# Contributing
+If you feel like you can improve the plugin any way, then you are more than welcome to contribute to PlotSquared. It would be highly appreciated if you made sure to test your code before committing it, as it will save us a lot of time and effort.
+
+### Code Style
+If you are planning to commit any changes to the project, it would be highly appreciated if you were to follow the project code style conventions. To make this easier we have provided settings that can be imported into your IDE.
+
+Eclipse: `Window > Preferences > Java > Code Style > Formatter` Press `Import` and select `...path/to/project/code_style.xml`
+
+IntelliJ: `File > Settings > Editor > Code Style`. Next to "Scheme" there is a cog wheel, press that and then `Import Scheme > IntelliJ IDEA Code Style XML` and then select `..path/to/project/code_style.xml`

Core/build.gradle

@@ -0,0 +1,89 @@
+repositories {
+    maven { url = "https://jitpack.io" }
+}
+def textVersion = "3.0.2"
+
+dependencies {
+    implementation("org.yaml:snakeyaml:1.25")
+    implementation("com.google.code.gson:gson:2.8.6") {
+        because("Minecraft uses GSON 2.8.0")
+        force = true
+    }
+    implementation("org.projectlombok:lombok:1.18.10")
+    compileOnly("org.projectlombok:lombok:1.18.8")
+    testCompileOnly("org.projectlombok:lombok:1.18.8")
+    annotationProcessor("org.projectlombok:lombok:1.18.8")
+    testAnnotationProcessor("org.projectlombok:lombok:1.18.8")
+    implementation("com.github.Sauilitired:Jenkins4J:2.0-SNAPSHOT")
+    implementation("com.squareup.okhttp3:okhttp:4.2.2")
+    implementation("com.squareup.okio:okio:2.4.1")
+    implementation("org.jetbrains.kotlin:kotlin-stdlib:1.3.61")
+}
+
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
+
+processResources {
+    from("src/main/resources") {
+        include "plugin.properties"
+        expand(
+                version: "${project.parent.version}",
+                name: project.parent.name,
+                commit: "${git.head().abbreviatedId}",
+                date: "${git.head().getDate().format("yy.MM.dd")}",
+        )
+    }
+}
+
+//noinspection GroovyAssignabilityCheck
+jar.archiveFileName = "PlotSquared-API-${project.parent.version}.jar"
+jar.destinationDirectory = file("../mvn/com/github/intellectualsites/plotsquared/PlotSquared-API/" + project.parent.version)
+task createPom {
+    doLast {
+        pom {
+            project {
+                groupId = "com.github.intellectualsites.plotsquared"
+                artifactId = "PlotSquared-API"
+                version = project.parent.version
+            }
+        }.writeTo("../mvn/com/github/intellectualsites/plotsquared/PlotSquared-API/${project.parent.version}/PlotSquared-API-${project.parent.version}.pom")
+        pom {
+            project {
+                groupId = "com.github.intellectualsites.plotsquared"
+                artifactId = "PlotSquared-API"
+                version = "latest"
+            }
+        }.writeTo("../mvn/com/github/intellectualsites/plotsquared/PlotSquared-API/latest/PlotSquared-API-latest.pom")
+    }
+}
+
+task copyFiles {
+    doLast {
+        copy {
+            from("../mvn/com/github/intellectualsites/plotsquared/PlotSquared-API/${project.parent.version}/")
+            into("../mvn/com/github/intellectualsites/plotsquared/PlotSquared-API/latest/")
+            include("*.jar")
+            rename("PlotSquared-API-${project.parent.version}.jar", "PlotSquared-API-latest.jar")
+        }
+    }
+}
+
+shadowJar {
+    dependencies {
+        include(dependency("net.kyori:text-api:3.0.2"))
+        include(dependency("net.kyori:text-serializer-gson:3.0.2"))
+        include(dependency("net.kyori:text-serializer-legacy:3.0.2"))
+        include(dependency("net.kyori:text-serializer-plain:3.0.2"))
+    }
+    relocate('net.kyori.text', 'com.github.intellectualsites.plotsquared.formatting.text')
+}
+
+shadowJar.doLast {
+    task ->
+        ant.checksum file: task.archivePath
+}
+
+build.dependsOn(shadowJar)
+
+build.finalizedBy(copyFiles)
+copyFiles.dependsOn(createPom)

Core/src/main/java/com/github/intellectualsites/plotsquared/api/PlotAPI.java

@@ -0,0 +1,214 @@
+package com.github.intellectualsites.plotsquared.api;
+
+import com.github.intellectualsites.plotsquared.configuration.file.YamlConfiguration;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.config.Captions;
+import com.github.intellectualsites.plotsquared.plot.flag.Flag;
+import com.github.intellectualsites.plotsquared.plot.flag.Flags;
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import com.github.intellectualsites.plotsquared.plot.object.PlotArea;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.util.ChunkManager;
+import com.github.intellectualsites.plotsquared.plot.util.MainUtil;
+import com.github.intellectualsites.plotsquared.plot.util.SchematicHandler;
+import com.github.intellectualsites.plotsquared.plot.util.UUIDHandler;
+import com.github.intellectualsites.plotsquared.plot.util.block.GlobalBlockQueue;
+import com.github.intellectualsites.plotsquared.plot.uuid.UUIDWrapper;
+import lombok.NoArgsConstructor;
+
+import java.util.Collections;
+import java.util.Set;
+import java.util.UUID;
+
+/**
+ * PlotSquared API.
+ *
+ * <p>Useful classes:
+ * <ul>
+ * <li>{@link PlotPlayer}</li>
+ * <li>{@link Plot}</li>
+ * <li>{@link com.github.intellectualsites.plotsquared.plot.object.Location}</li>
+ * <li>{@link PlotArea}</li>
+ * <li>{@link PlotSquared}</li>
+ * </ul>
+ *
+ * @version 3.3.3
+ */
+@SuppressWarnings({"unused", "WeakerAccess"}) @NoArgsConstructor public class PlotAPI {
+
+    /**
+     * Gets all plots.
+     *
+     * @return all plots
+     * @see PlotSquared#getPlots()
+     */
+    public Set<Plot> getAllPlots() {
+        return PlotSquared.get().getPlots();
+    }
+
+    /**
+     * Gets all plots for a player.
+     *
+     * @param player Player, whose plots to search for
+     * @return all plots that a player owns
+     */
+    public Set<Plot> getPlayerPlots(PlotPlayer player) {
+        return PlotSquared.get().getPlots(player);
+    }
+
+    /**
+     * Adds a plot world.
+     *
+     * @param plotArea Plot World Object
+     * @see PlotSquared#addPlotArea(PlotArea)
+     */
+    public void addPlotArea(PlotArea plotArea) {
+        PlotSquared.get().addPlotArea(plotArea);
+    }
+
+    /**
+     * Gets the configuration file for this plugin.
+     *
+     * @return the configuration file for PlotSquared
+     * =
+     */
+    public YamlConfiguration getConfig() {
+        return PlotSquared.get().getConfig();
+    }
+
+    /**
+     * Gets the PlotSquared storage file.
+     *
+     * @return storage configuration
+     * @see PlotSquared#storage
+     */
+    public YamlConfiguration getStorage() {
+        return PlotSquared.get().storage;
+    }
+
+    /**
+     * ChunkManager class contains several useful methods.
+     * <ul>
+     * <li>Chunk deletion</li>
+     * <li>Moving or copying regions</li>
+     * <li>Plot swapping</li>
+     * <li>Entity Tracking</li>
+     * <li>Region Regeneration</li>
+     * </ul>
+     *
+     * @return ChunkManager
+     * @see ChunkManager
+     */
+    public ChunkManager getChunkManager() {
+        return ChunkManager.manager;
+    }
+
+    /**
+     * Gets the block/biome set queue
+     *
+     * @return GlobalBlockQueue.IMP
+     */
+    public GlobalBlockQueue getBlockQueue() {
+        return GlobalBlockQueue.IMP;
+    }
+
+    /**
+     * UUIDWrapper class has basic methods for getting UUIDS. It's recommended
+     * to use the UUIDHandler class instead.
+     *
+     * @return UUIDWrapper
+     * @see UUIDWrapper
+     */
+    public UUIDWrapper getUUIDWrapper() {
+        return UUIDHandler.getUUIDWrapper();
+    }
+
+    /**
+     * SchematicHandler class contains methods related to pasting, reading
+     * and writing schematics.
+     *
+     * @return SchematicHandler
+     * @see SchematicHandler
+     */
+    public SchematicHandler getSchematicHandler() {
+        return SchematicHandler.manager;
+    }
+
+    /**
+     * Gets a list of PlotAreas in the world.
+     *
+     * @param world The world to check for plot areas
+     * @return A set of PlotAreas
+     */
+    public Set<PlotArea> getPlotAreas(String world) {
+        if (world == null) {
+            return Collections.emptySet();
+        }
+        return PlotSquared.get().getPlotAreas(world);
+    }
+
+    /**
+     * Send a message to the console. The message supports color codes.
+     *
+     * @param message the message
+     * @see MainUtil#sendConsoleMessage(Captions, String...)
+     */
+    public void sendConsoleMessage(String message) {
+        PlotSquared.log(message);
+    }
+
+    /**
+     * Sends a message to the console.
+     *
+     * @param caption the message
+     * @see #sendConsoleMessage(String)
+     * @see Captions
+     */
+    public void sendConsoleMessage(Captions caption) {
+        sendConsoleMessage(caption.getTranslated());
+    }
+
+    /**
+     * Registers a flag for use in plots.
+     *
+     * @param flag the flag to register
+     */
+    public void addFlag(Flag<?> flag) {
+        Flags.registerFlag(flag);
+    }
+
+    /**
+     * Gets the PlotSquared class.
+     *
+     * @return PlotSquared Class
+     * @see PlotSquared
+     */
+    public PlotSquared getPlotSquared() {
+        return PlotSquared.get();
+    }
+
+    /**
+     * Gets the PlotPlayer for a UUID.
+     *
+     * <p><i>Please note that PlotSquared can be configured to provide
+     * different UUIDs than bukkit</i>
+     *
+     * @param uuid the uuid of the player to wrap
+     * @return a {@code PlotPlayer}
+     * @see PlotPlayer#wrap(Object)
+     */
+    public PlotPlayer wrapPlayer(UUID uuid) {
+        return PlotPlayer.wrap(uuid);
+    }
+
+    /**
+     * Gets the PlotPlayer for a username.
+     *
+     * @param player the player to wrap
+     * @return a {@code PlotPlayer}
+     * @see PlotPlayer#wrap(Object)
+     */
+    public PlotPlayer wrapPlayer(String player) {
+        return PlotPlayer.wrap(player);
+    }
+}

Core/src/main/java/com/github/intellectualsites/plotsquared/commands/Argument.java

@@ -0,0 +1,68 @@
+package com.github.intellectualsites.plotsquared.commands;
+
+import com.github.intellectualsites.plotsquared.plot.object.PlotId;
+
+public abstract class Argument<T> {
+
+    public static final Argument<Integer> Integer = new Argument<Integer>("int", 16) {
+        @Override public Integer parse(String in) {
+            Integer value = null;
+            try {
+                value = java.lang.Integer.parseInt(in);
+            } catch (Exception ignored) {
+            }
+            return value;
+        }
+    };
+    public static final Argument<Boolean> Boolean = new Argument<Boolean>("boolean", true) {
+        @Override public Boolean parse(String in) {
+            Boolean value = null;
+            if (in.equalsIgnoreCase("true") || in.equalsIgnoreCase("Yes") || in
+                .equalsIgnoreCase("1")) {
+                value = true;
+            } else if (in.equalsIgnoreCase("false") || in.equalsIgnoreCase("No") || in
+                .equalsIgnoreCase("0")) {
+                value = false;
+            }
+            return value;
+        }
+    };
+    public static final Argument<String> String = new Argument<String>("String", "Example") {
+        @Override public String parse(String in) {
+            return in;
+        }
+    };
+    public static final Argument<String> PlayerName =
+        new Argument<String>("PlayerName", "<player|*>") {
+            @Override public String parse(String in) {
+                return in.length() <= 16 ? in : null;
+            }
+        };
+    public static final Argument<PlotId> PlotID =
+        new Argument<PlotId>("PlotID", new PlotId(-6, 3)) {
+            @Override public PlotId parse(String in) {
+                return PlotId.fromString(in);
+            }
+        };
+    private final String name;
+    private final T example;
+
+    public Argument(String name, T example) {
+        this.name = name;
+        this.example = example;
+    }
+
+    public abstract T parse(String in);
+
+    @Override public final String toString() {
+        return this.getName();
+    }
+
+    public final String getName() {
+        return this.name;
+    }
+
+    public final T getExample() {
+        return this.example;
+    }
+}

Core/src/main/java/com/github/intellectualsites/plotsquared/commands/Command.java

@@ -0,0 +1,604 @@
+package com.github.intellectualsites.plotsquared.commands;
+
+import com.github.intellectualsites.plotsquared.configuration.file.YamlConfiguration;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.commands.CommandCategory;
+import com.github.intellectualsites.plotsquared.plot.commands.MainCommand;
+import com.github.intellectualsites.plotsquared.plot.commands.RequiredType;
+import com.github.intellectualsites.plotsquared.plot.config.Captions;
+import com.github.intellectualsites.plotsquared.plot.object.PlotMessage;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.RunnableVal2;
+import com.github.intellectualsites.plotsquared.plot.object.RunnableVal3;
+import com.github.intellectualsites.plotsquared.plot.util.MainUtil;
+import com.github.intellectualsites.plotsquared.plot.util.MathMan;
+import com.github.intellectualsites.plotsquared.plot.util.Permissions;
+import com.github.intellectualsites.plotsquared.plot.util.StringComparison;
+import com.github.intellectualsites.plotsquared.plot.util.StringMan;
+
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+
+public abstract class Command {
+
+    // May be none
+    private final ArrayList<Command> allCommands = new ArrayList<>();
+    private final ArrayList<Command> dynamicCommands = new ArrayList<>();
+    private final HashMap<String, Command> staticCommands = new HashMap<>();
+
+    // Parent command (may be null)
+    private final Command parent;
+    private final boolean isStatic;
+    // The command ID
+    private String id;
+    private List<String> aliases;
+    private RequiredType required;
+    private String usage;
+    private String description;
+    private String permission;
+    private boolean confirmation;
+    private CommandCategory category;
+    private Argument[] arguments;
+
+    public Command(Command parent, boolean isStatic, String id, String permission,
+        RequiredType required, CommandCategory category) {
+        this.parent = parent;
+        this.isStatic = isStatic;
+        this.id = id;
+        this.permission = permission;
+        this.required = required;
+        this.category = category;
+        this.aliases = Arrays.asList(id);
+        if (this.parent != null) {
+            this.parent.register(this);
+        }
+    }
+
+    public Command(Command parent, boolean isStatic) {
+        this.parent = parent;
+        this.isStatic = isStatic;
+        CommandDeclaration cdAnnotation = getClass().getAnnotation(CommandDeclaration.class);
+        if (cdAnnotation != null) {
+            init(cdAnnotation);
+        }
+        for (final Method method : getClass().getDeclaredMethods()) {
+            if (method.isAnnotationPresent(CommandDeclaration.class)) {
+                Class<?>[] types = method.getParameterTypes();
+                // final PlotPlayer player, String[] args, RunnableVal3<Command,Runnable,Runnable> confirm, RunnableVal2<Command, CommandResult>
+                // whenDone
+                if (types.length == 5 && types[0] == Command.class && types[1] == PlotPlayer.class
+                    && types[2] == String[].class && types[3] == RunnableVal3.class
+                    && types[4] == RunnableVal2.class) {
+                    Command tmp = new Command(this, true) {
+                        @Override public CompletableFuture<Boolean> execute(PlotPlayer player, String[] args,
+                            RunnableVal3<Command, Runnable, Runnable> confirm,
+                            RunnableVal2<Command, CommandResult> whenDone) {
+                            try {
+                                method.invoke(Command.this, this, player, args, confirm, whenDone);
+                                return CompletableFuture.completedFuture(true);
+                            } catch (IllegalAccessException | InvocationTargetException e) {
+                                e.printStackTrace();
+                            }
+                            return CompletableFuture.completedFuture(false);
+                        }
+                    };
+                    tmp.init(method.getAnnotation(CommandDeclaration.class));
+                }
+            }
+        }
+    }
+
+    public Command getParent() {
+        return this.parent;
+    }
+
+    public String getId() {
+        return this.id;
+    }
+
+    public String getFullId() {
+        if (this.parent != null && this.parent.getParent() != null) {
+            return this.parent.getFullId() + "." + this.id;
+        }
+        return this.id;
+    }
+
+    public List<Command> getCommands(CommandCaller player) {
+        List<Command> commands = new ArrayList<>();
+        for (Command cmd : this.allCommands) {
+            if (cmd.canExecute(player, false)) {
+                commands.add(cmd);
+            }
+        }
+        return commands;
+    }
+
+    public List<Command> getCommands(CommandCategory category, CommandCaller player) {
+        List<Command> commands = getCommands(player);
+        if (category != null) {
+            commands.removeIf(command -> command.category != category);
+        }
+        return commands;
+    }
+
+    public List<Command> getCommands() {
+        return this.allCommands;
+    }
+
+    public boolean hasConfirmation(CommandCaller player) {
+        return this.confirmation && !player.hasPermission(getPermission() + ".confirm.bypass");
+    }
+
+    public List<String> getAliases() {
+        return this.aliases;
+    }
+
+    public String getDescription() {
+        return this.description;
+    }
+
+    public RequiredType getRequiredType() {
+        return this.required;
+    }
+
+    public Argument[] getRequiredArguments() {
+        return this.arguments;
+    }
+
+    public void setRequiredArguments(Argument[] arguments) {
+        this.arguments = arguments;
+    }
+
+    public void init(CommandDeclaration declaration) {
+        this.id = declaration.command();
+        this.permission = declaration.permission();
+        this.required = declaration.requiredType();
+        this.category = declaration.category();
+        List<String> aliasOptions = new ArrayList<>();
+        aliasOptions.add(this.id);
+        aliasOptions.addAll(Arrays.asList(declaration.aliases()));
+        HashMap<String, Object> options = new HashMap<>();
+        options.put("aliases", aliasOptions);
+        options.put("description", declaration.description());
+        options.put("usage", declaration.usage());
+        options.put("confirmation", declaration.confirmation());
+        boolean set = false;
+        YamlConfiguration commands =
+            PlotSquared.get() == null ? new YamlConfiguration() : PlotSquared.get().commands;
+        for (Map.Entry<String, Object> entry : options.entrySet()) {
+            String key = this.getFullId() + "." + entry.getKey();
+            if (!commands.contains(key)) {
+                commands.set(key, entry.getValue());
+                set = true;
+            }
+        }
+        if (set && PlotSquared.get() != null) {
+            try {
+                commands.save(PlotSquared.get().commandsFile);
+            } catch (IOException e) {
+                e.printStackTrace();
+
+            }
+        }
+        this.aliases = commands.getStringList(this.getFullId() + ".aliases");
+        this.description = commands.getString(this.getFullId() + ".description");
+        this.usage = commands.getString(this.getFullId() + ".usage");
+        this.confirmation = commands.getBoolean(this.getFullId() + ".confirmation");
+        if (this.parent != null) {
+            this.parent.register(this);
+        }
+    }
+
+    public void register(Command command) {
+        if (command.isStatic) {
+            for (String alias : command.aliases) {
+                this.staticCommands.put(alias.toLowerCase(), command);
+            }
+        } else {
+            this.dynamicCommands.add(command);
+        }
+        this.allCommands.add(command);
+    }
+
+    public String getPermission() {
+        if (this.permission != null && !this.permission.isEmpty()) {
+            return this.permission;
+        }
+        if (this.parent == null) {
+            return "plots.use";
+        }
+        return "plots." + getFullId();
+    }
+
+    public <T> void paginate(PlotPlayer player, List<T> c, int size, int page,
+        RunnableVal3<Integer, T, PlotMessage> add, String baseCommand, String header) {
+        // Calculate pages & index
+        if (page < 0) {
+            page = 0;
+        }
+        int totalPages = (int) Math.ceil(c.size() / size);
+        if (page > totalPages) {
+            page = totalPages;
+        }
+        int max = page * size + size;
+        if (max > c.size()) {
+            max = c.size();
+        }
+        // Send the header
+        header = header.replaceAll("%cur", page + 1 + "").replaceAll("%max", totalPages + 1 + "")
+            .replaceAll("%amount%", c.size() + "").replaceAll("%word%", "all");
+        MainUtil.sendMessage(player, header);
+        // Send the page content
+        List<T> subList = c.subList(page * size, max);
+        int i = page * size;
+        for (T obj : subList) {
+            i++;
+            PlotMessage msg = new PlotMessage();
+            add.run(i, obj, msg);
+            msg.send(player);
+        }
+        // Send the footer
+        if (page < totalPages && page > 0) { // Back | Next
+            new PlotMessage().text("<-").color("$1").command(baseCommand + " " + page).text(" | ")
+                .color("$3").text("->").color("$1").command(baseCommand + " " + (page + 2))
+                .text(Captions.CLICKABLE.getTranslated()).color("$2").send(player);
+            return;
+        }
+        if (page == 0 && totalPages != 0) { // Next
+            new PlotMessage().text("<-").color("$3").text(" | ").color("$3").text("->").color("$1")
+                .command(baseCommand + " " + 2).text(Captions.CLICKABLE.getTranslated()).color("$2")
+                .send(player);
+            return;
+        }
+        if (totalPages != 0) { // Back
+            new PlotMessage().text("<-").color("$1").command(baseCommand + " " + page).text(" | ")
+                .color("$3").text("->").color("$3").text(Captions.CLICKABLE.getTranslated())
+                .color("$2")
+                .send(player);
+        }
+    }
+
+    /**
+     * @param player  Caller
+     * @param args Arguments
+     * @param confirm Instance, Success, Failure
+     * @return CompletableFuture true if the command executed fully, false in
+     * any other case
+     */
+    public CompletableFuture<Boolean> execute(PlotPlayer player, String[] args,
+        RunnableVal3<Command, Runnable, Runnable> confirm,
+        RunnableVal2<Command, CommandResult> whenDone) throws CommandException {
+        if (args.length == 0 || args[0] == null) {
+            if (this.parent == null) {
+                MainCommand.getInstance().help.displayHelp(player, null, 0);
+            } else {
+                Captions.COMMAND_SYNTAX.send(player, getUsage());
+            }
+            return CompletableFuture.completedFuture(false);
+        }
+        if (this.allCommands.isEmpty()) {
+            player.sendMessage(
+                "Not Implemented: https://github.com/IntellectualSites/PlotSquared/issues/new");
+            return CompletableFuture.completedFuture(false);
+        }
+        Command cmd = getCommand(args[0]);
+        if (cmd == null) {
+            if (this.parent != null) {
+                Captions.COMMAND_SYNTAX.send(player, getUsage());
+                return CompletableFuture.completedFuture(false);
+            }
+            // Help command
+            try {
+                if (!MathMan.isInteger(args[0])) {
+                    CommandCategory.valueOf(args[0].toUpperCase());
+                }
+                // This will default certain syntax to the help command
+                // e.g. /plot, /plot 1, /plot claiming
+                MainCommand.getInstance().help.execute(player, args, null, null);
+                return CompletableFuture.completedFuture(false);
+            } catch (IllegalArgumentException ignored) {
+            }
+            // Command recommendation
+            MainUtil.sendMessage(player, Captions.NOT_VALID_SUBCOMMAND);
+            List<Command> commands = getCommands(player);
+            if (commands.isEmpty()) {
+                MainUtil.sendMessage(player, Captions.DID_YOU_MEAN,
+                    MainCommand.getInstance().help.getUsage());
+                return CompletableFuture.completedFuture(false);
+            }
+            HashSet<String> setArgs = new HashSet<>(args.length);
+            for (String arg : args) {
+                setArgs.add(arg.toLowerCase());
+            }
+            String[] allArgs = setArgs.toArray(new String[0]);
+            int best = 0;
+            for (Command current : commands) {
+                int match = getMatch(allArgs, current);
+                if (match > best) {
+                    cmd = current;
+                }
+            }
+            if (cmd == null) {
+                cmd = new StringComparison<>(args[0], this.allCommands).getMatchObject();
+            }
+            MainUtil.sendMessage(player, Captions.DID_YOU_MEAN, cmd.getUsage());
+            return CompletableFuture.completedFuture(false);
+        }
+        String[] newArgs = Arrays.copyOfRange(args, 1, args.length);
+        if (!cmd.checkArgs(player, newArgs) || !cmd.canExecute(player, true)) {
+            return CompletableFuture.completedFuture(false);
+        }
+        try {
+            cmd.execute(player, newArgs, confirm, whenDone);
+        } catch (CommandException e) {
+            e.perform(player);
+        }
+        return CompletableFuture.completedFuture(true);
+    }
+
+    public boolean checkArgs(CommandCaller player, String[] args) {
+        Argument<?>[] reqArgs = getRequiredArguments();
+        if (reqArgs != null && reqArgs.length > 0) {
+            boolean failed = args.length < reqArgs.length;
+            String[] baseSplit = getCommandString().split(" ");
+            String[] fullSplit = getUsage().split(" ");
+            String base = getCommandString();
+            if (fullSplit.length - baseSplit.length < reqArgs.length) {
+                String[] tmp = new String[baseSplit.length + reqArgs.length];
+                System.arraycopy(fullSplit, 0, tmp, 0, fullSplit.length);
+                fullSplit = tmp;
+            }
+            for (int i = 0; i < reqArgs.length; i++) {
+                fullSplit[i + baseSplit.length] = reqArgs[i].getExample().toString();
+                failed = failed || reqArgs[i].parse(args[i]) == null;
+            }
+            if (failed) {
+                Captions.COMMAND_SYNTAX.send(player, StringMan.join(fullSplit, " "));
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public int getMatch(String[] args, Command cmd) {
+        String perm = cmd.getPermission();
+        HashSet<String> desc = new HashSet<>();
+        int count = cmd.getAliases().stream().filter(alias -> alias.startsWith(args[0]))
+            .mapToInt(alias -> 5).sum();
+        Collections.addAll(desc, cmd.getDescription().split(" "));
+        for (String arg : args) {
+            if (perm.startsWith(arg)) {
+                count++;
+            }
+            if (desc.contains(arg)) {
+                count++;
+            }
+        }
+        String[] usage = cmd.getUsage().split(" ");
+        for (int i = 0; i < Math.min(4, usage.length); i++) {
+            int require;
+            if (usage[i].startsWith("<")) {
+                require = 1;
+            } else {
+                require = 0;
+            }
+            String[] split = usage[i].split("\\|| |\\>|\\<|\\[|\\]|\\{|\\}|\\_|\\/");
+            for (String aSplit : split) {
+                for (String arg : args) {
+                    if (arg.equalsIgnoreCase(aSplit)) {
+                        count += 5 - i + require;
+                    }
+                }
+            }
+        }
+        count += StringMan.intersection(desc, args);
+        return count;
+    }
+
+    public Command getCommand(String arg) {
+        Command cmd = this.staticCommands.get(arg.toLowerCase());
+        if (cmd == null) {
+            for (Command command : this.dynamicCommands) {
+                if (command.matches(arg)) {
+                    return command;
+                }
+            }
+        }
+        return cmd;
+    }
+
+    public Command getCommand(Class clazz) {
+        for (Command cmd : this.allCommands) {
+            if (cmd.getClass() == clazz) {
+                return cmd;
+            }
+        }
+        return null;
+    }
+
+    public Command getCommandById(String id) {
+        Command exact = this.staticCommands.get(id);
+        if (exact != null) {
+            return exact;
+        }
+        for (Command cmd : this.allCommands) {
+            if (cmd.getId().equals(id)) {
+                return cmd;
+            }
+        }
+        return null;
+    }
+
+    public boolean canExecute(CommandCaller player, boolean message) {
+        if (player == null) {
+            return true;
+        }
+        if (!this.required.allows(player)) {
+            if (message) {
+                MainUtil.sendMessage(player, this.required == RequiredType.PLAYER ?
+                    Captions.IS_CONSOLE :
+                    Captions.NOT_CONSOLE);
+            }
+        } else if (!Permissions.hasPermission(player, getPermission())) {
+            if (message) {
+                Captions.NO_PERMISSION.send(player, getPermission());
+            }
+        } else {
+            return true;
+        }
+        return false;
+    }
+
+    public boolean matches(String arg) {
+        arg = arg.toLowerCase();
+        return StringMan.isEqual(arg, this.id) || this.aliases.contains(arg);
+    }
+
+    public String getCommandString() {
+        if (this.parent == null) {
+            return "/" + toString();
+        } else {
+            return this.parent.getCommandString() + " " + toString();
+        }
+    }
+
+    public String getUsage() {
+        if (this.usage != null && !this.usage.isEmpty()) {
+            if (this.usage.startsWith("/")) {
+                return this.usage;
+            }
+            return getCommandString() + " " + this.usage;
+        }
+        if (this.allCommands.isEmpty()) {
+            return getCommandString();
+        }
+        StringBuilder args = new StringBuilder("[");
+        String prefix = "";
+        for (Command cmd : this.allCommands) {
+            args.append(prefix).append(cmd.isStatic ? cmd.toString() : "<" + cmd + ">");
+            prefix = "|";
+        }
+        return getCommandString() + " " + args + "]";
+    }
+
+    public Collection<Command> tabOf(PlotPlayer player, String[] input, boolean space,
+        String... args) {
+        if (!space) {
+            return null;
+        }
+        List<Command> result = new ArrayList<>();
+        int index = input.length;
+        for (String arg : args) {
+            arg = arg.replace(getCommandString() + " ", "");
+            String[] split = arg.split(" ");
+            if (split.length <= index) {
+                continue;
+            }
+            arg = StringMan.join(Arrays.copyOfRange(split, index, split.length), " ");
+            Command cmd = new Command(null, false, arg, getPermission(), getRequiredType(), null) {
+            };
+            result.add(cmd);
+        }
+        return result;
+    }
+
+    public Collection<Command> tab(PlotPlayer player, String[] args, boolean space) {
+        switch (args.length) {
+            case 0:
+                return this.allCommands;
+            case 1:
+                String arg = args[0].toLowerCase();
+                if (space) {
+                    Command cmd = getCommand(arg);
+                    if (cmd != null && cmd.canExecute(player, false)) {
+                        return cmd.tab(player, Arrays.copyOfRange(args, 1, args.length), space);
+                    } else {
+                        return null;
+                    }
+                } else {
+                    Set<Command> commands = new HashSet<Command>();
+                    for (Map.Entry<String, Command> entry : this.staticCommands.entrySet()) {
+                        if (entry.getKey().startsWith(arg) && entry.getValue()
+                            .canExecute(player, false)) {
+                            commands.add(entry.getValue());
+                        }
+                    }
+                    return commands;
+                }
+            default:
+                Command cmd = getCommand(args[0]);
+                if (cmd != null) {
+                    return cmd.tab(player, Arrays.copyOfRange(args, 1, args.length), space);
+                } else {
+                    return null;
+                }
+        }
+    }
+
+    @Override public String toString() {
+        return !this.aliases.isEmpty() ? this.aliases.get(0) : this.id;
+    }
+
+    @Override public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        Command other = (Command) obj;
+        if (this.hashCode() != other.hashCode()) {
+            return false;
+        }
+        return this.getFullId().equals(other.getFullId());
+    }
+
+    @Override public int hashCode() {
+        return this.getFullId().hashCode();
+    }
+
+    public void checkTrue(boolean mustBeTrue, Captions message, Object... args) {
+        if (!mustBeTrue) {
+            throw new CommandException(message, args);
+        }
+    }
+
+    public <T extends Object> T check(T object, Captions message, Object... args) {
+        if (object == null) {
+            throw new CommandException(message, args);
+        }
+        return object;
+    }
+
+    public enum CommandResult {
+        FAILURE, SUCCESS
+    }
+
+
+    public static class CommandException extends RuntimeException {
+        private final Object[] args;
+        private final Captions message;
+
+        public CommandException(Captions message, Object... args) {
+            this.message = message;
+            this.args = args;
+        }
+
+        public void perform(CommandCaller player) {
+            if (player != null && message != null) {
+                message.send(player, args);
+            }
+        }
+    }
+}

Core/src/main/java/com/github/intellectualsites/plotsquared/commands/CommandCaller.java

@@ -0,0 +1,24 @@
+package com.github.intellectualsites.plotsquared.commands;
+
+import com.github.intellectualsites.plotsquared.plot.commands.RequiredType;
+
+public interface CommandCaller {
+
+    /**
+     * Send the player a message.
+     *
+     * @param message the message to send
+     */
+    void sendMessage(String message);
+
+    /**
+     * Check the player's permissions. <i>Will be cached if permission caching is enabled.</i>
+     *
+     * @param permission the name of the permission
+     */
+    boolean hasPermission(String permission);
+
+    boolean isPermissionSet(String permission);
+
+    RequiredType getSuperCaller();
+}

Core/src/main/java/com/github/intellectualsites/plotsquared/commands/CommandDeclaration.java

@@ -1,15 +1,14 @@
-package com.plotsquared.general.commands;
+package com.github.intellectualsites.plotsquared.commands;
+
+import com.github.intellectualsites.plotsquared.plot.commands.CommandCategory;
+import com.github.intellectualsites.plotsquared.plot.commands.RequiredType;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-import com.intellectualcrafters.plot.commands.CommandCategory;
-import com.intellectualcrafters.plot.commands.RequiredType;
-
-@Target(ElementType.TYPE)
-@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME)
 public @interface CommandDeclaration {
 
     String command();
@@ -24,5 +23,7 @@ public @interface CommandDeclaration {
 
     RequiredType requiredType() default RequiredType.NONE;
 
-    CommandCategory category();
+    CommandCategory category() default CommandCategory.INFO;
+
+    boolean confirmation() default false;
 }

Core/src/main/java/com/github/intellectualsites/plotsquared/configuration/Configuration.java

@@ -1,84 +1,86 @@
-package com.intellectualcrafters.configuration;
+package com.github.intellectualsites.plotsquared.configuration;
 
 import java.util.Map;
 
 /**
- * Represents a source of configurable options and settings
+ * Represents a source of configurable options and settings.
  */
 public interface Configuration extends ConfigurationSection {
     /**
      * Sets the default value of the given path as provided.
      * <p>
-     * If no source {@link Configuration} was provided as a default
+     * <p>If no source {@link Configuration} was provided as a default
      * collection, then a new {@link MemoryConfiguration} will be created to
-     * hold the new default value.
+     * hold the new default value.</p>
      * <p>
-     * If value is null, the value will be removed from the default
-     * Configuration source.
+     * <p>If value is null, the value will be removed from the default
+     * Configuration source.</p>
      *
-     * @param path Path of the value to set.
+     * @param path  Path of the value to set.
      * @param value Value to set the default to.
      * @throws IllegalArgumentException Thrown if path is null.
      */
-    public void addDefault(String path, Object value);
+    @Override void addDefault(String path, Object value);
 
     /**
      * Sets the default values of the given paths as provided.
      * <p>
-     * If no source {@link Configuration} was provided as a default
+     * <p>If no source {@link Configuration} was provided as a default
      * collection, then a new {@link MemoryConfiguration} will be created to
-     * hold the new default values.
+     * hold the new default values.</p>
      *
      * @param defaults A map of Path->Values to add to defaults.
      * @throws IllegalArgumentException Thrown if defaults is null.
      */
-    public void addDefaults(Map<String, Object> defaults);
+    void addDefaults(Map<String, Object> defaults);
 
     /**
      * Sets the default values of the given paths as provided.
      * <p>
-     * If no source {@link Configuration} was provided as a default
+     * <p>If no source {@link Configuration} was provided as a default
      * collection, then a new {@link MemoryConfiguration} will be created to
-     * hold the new default value.
+     * hold the new default value.</p>
      * <p>
-     * This method will not hold a reference to the specified Configuration,
+     * <p>This method will not hold a reference to the specified Configuration,
      * nor will it automatically update if that Configuration ever changes. If
-     * you require this, you should set the default source with {@link
-     * #setDefaults(com.intellectualcrafters.configuration.Configuration)}.
+     * you check this, you should set the default source with {@link
+     * #setDefaults(Configuration)}.</p>
      *
      * @param defaults A configuration holding a list of defaults to copy.
      * @throws IllegalArgumentException Thrown if defaults is null or this.
      */
-    public void addDefaults(Configuration defaults);
-
-    /**
-     * Sets the source of all default values for this {@link Configuration}.
-     * <p>
-     * If a previous source was set, or previous default values were defined,
-     * then they will not be copied to the new source.
-     *
-     * @param defaults New source of default values for this configuration.
-     * @throws IllegalArgumentException Thrown if defaults is null or this.
-     */
-    public void setDefaults(Configuration defaults);
+    void addDefaults(Configuration defaults);
 
     /**
      * Gets the source {@link Configuration} for this configuration.
      * <p>
+     * <p>
      * If no configuration source was set, but default values were added, then
      * a {@link MemoryConfiguration} will be returned. If no source was set
-     * and no defaults were set, then this method will return null.
+     * and no defaults were set, then this method will return null.</p>
      *
      * @return Configuration source for default values, or null if none exist.
      */
-    public Configuration getDefaults();
+    Configuration getDefaults();
+
+    /**
+     * Sets the source of all default values for this {@link Configuration}.
+     * <p>
+     * <p>
+     * If a previous source was set, or previous default values were defined,
+     * then they will not be copied to the new source.</p>
+     *
+     * @param defaults New source of default values for this configuration.
+     * @throws IllegalArgumentException Thrown if defaults is null or this.
+     */
+    void setDefaults(Configuration defaults);
 
     /**
      * Gets the {@link ConfigurationOptions} for this {@link Configuration}.
      * <p>
-     * All setters through this method are chainable.
+     * <p>All setters through this method are chainable.</p>
      *
      * @return Options for this configuration
      */
-    public ConfigurationOptions options();
+    ConfigurationOptions options();
 }

Core/src/main/java/com/github/intellectualsites/plotsquared/configuration/ConfigurationOptions.java

@@ -1,13 +1,12 @@
-package com.intellectualcrafters.configuration;
+package com.github.intellectualsites.plotsquared.configuration;
 
 /**
  * Various settings for controlling the input and output of a {@link
- * Configuration}
+ * Configuration}.
  */
-public class ConfigurationOptions {
-    private char pathSeparator = '.';
-    private boolean copyDefaults = false;
+class ConfigurationOptions {
     private final Configuration configuration;
+    private boolean copyDefaults = false;
 
     protected ConfigurationOptions(Configuration configuration) {
         this.configuration = configuration;
@@ -24,42 +23,26 @@ public class ConfigurationOptions {
 
     /**
      * Gets the char that will be used to separate {@link
-     * ConfigurationSection}s
-     * <p>
-     * This value does not affect how the {@link Configuration} is stored,
-     * only in how you access the data. The default value is '.'.
+     * ConfigurationSection}s.
+     *
+     * <p> This value is always '.'.
      *
      * @return Path separator
      */
-    public char pathSeparator() {
-        return pathSeparator;
-    }
-
-    /**
-     * Sets the char that will be used to separate {@link
-     * ConfigurationSection}s
-     * <p>
-     * This value does not affect how the {@link Configuration} is stored,
-     * only in how you access the data. The default value is '.'.
-     *
-     * @param value Path separator
-     * @return This object, for chaining
-     */
-    public ConfigurationOptions pathSeparator(char value) {
-        this.pathSeparator = value;
-        return this;
+    char pathSeparator() {
+        return '.';
     }
 
     /**
      * Checks if the {@link Configuration} should copy values from its default
      * {@link Configuration} directly.
-     * <p>
-     * If this is true, all values in the default Configuration will be
+     *
+     * <p>If this is true, all values in the default Configuration will be
      * directly copied, making it impossible to distinguish between values
      * that were set and values that are provided by default. As a result,
-     * {@link ConfigurationSection#contains(java.lang.String)} will always
+     * {@link ConfigurationSection#contains(String)} will always
      * return the same value as {@link
-     * ConfigurationSection#isSet(java.lang.String)}. The default value is
+     * ConfigurationSection#isSet(String)}. The default value is
      * false.
      *
      * @return Whether or not defaults are directly copied
@@ -71,20 +54,20 @@ public class ConfigurationOptions {
     /**
      * Sets if the {@link Configuration} should copy values from its default
      * {@link Configuration} directly.
-     * <p>
-     * If this is true, all values in the default Configuration will be
+     *
+     * <p>If this is true, all values in the default Configuration will be
      * directly copied, making it impossible to distinguish between values
      * that were set and values that are provided by default. As a result,
-     * {@link ConfigurationSection#contains(java.lang.String)} will always
+     * {@link ConfigurationSection#contains(String)} will always
      * return the same value as {@link
-     * ConfigurationSection#isSet(java.lang.String)}. The default value is
+     * ConfigurationSection#isSet(String)}. The default value is
      * false.
      *
      * @param value Whether or not defaults are directly copied
      * @return This object, for chaining
      */
     public ConfigurationOptions copyDefaults(boolean value) {
-        this.copyDefaults = value;
+        copyDefaults = value;
         return this;
     }
 }

Core/src/main/java/com/github/intellectualsites/plotsquared/configuration/ConfigurationSection.java

@@ -1,266 +1,272 @@
-package com.intellectualcrafters.configuration;
+package com.github.intellectualsites.plotsquared.configuration;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 /**
- * Represents a section of a {@link Configuration}
+ * Represents a section of a {@link Configuration}.
  */
 public interface ConfigurationSection {
+
     /**
      * Gets a set containing all keys in this section.
-     * <p>
-     * If deep is set to true, then this will contain all the keys within any
+     *
+     * <p>If deep is set to true, then this will contain all the keys within any
      * child {@link ConfigurationSection}s (and their children, etc). These
      * will be in a valid path notation for you to use.
-     * <p>
-     * If deep is set to false, then this will contain only the keys of any
+     *
+     * <p>If deep is set to false, then this will contain only the keys of any
      * direct children, and not their own children.
      *
      * @param deep Whether or not to get a deep list, as opposed to a shallow
-     *     list.
+     *             list.
      * @return Set of keys contained within this ConfigurationSection.
      */
-    public Set<String> getKeys(boolean deep);
+    Set<String> getKeys(boolean deep);
 
     /**
      * Gets a Map containing all keys and their values for this section.
-     * <p>
-     * If deep is set to true, then this will contain all the keys and values
+     *
+     * <p>If deep is set to true, then this will contain all the keys and values
      * within any child {@link ConfigurationSection}s (and their children,
      * etc). These keys will be in a valid path notation for you to use.
-     * <p>
-     * If deep is set to false, then this will contain only the keys and
+     *
+     * <p>If deep is set to false, then this will contain only the keys and
      * values of any direct children, and not their own children.
      *
      * @param deep Whether or not to get a deep list, as opposed to a shallow
-     *     list.
+     *             list.
      * @return Map of keys and values of this section.
      */
-    public Map<String, Object> getValues(boolean deep);
+    Map<String, Object> getValues(boolean deep);
 
     /**
      * Checks if this {@link ConfigurationSection} contains the given path.
-     * <p>
-     * If the value for the requested path does not exist but a default value
+     *
+     * <p>If the value for the requested path does not exist but a default value
      * has been specified, this will return true.
      *
      * @param path Path to check for existence.
      * @return True if this section contains the requested path, either via
-     *     default or being set.
-     * @throws IllegalArgumentException Thrown when path is null.
+     * default or being set.
+     * @throws IllegalArgumentException Thrown when path is {@code null}.
      */
-    public boolean contains(String path);
+    boolean contains(String path);
 
     /**
      * Checks if this {@link ConfigurationSection} has a value set for the
      * given path.
-     * <p>
-     * If the value for the requested path does not exist but a default value
+     *
+     * <p>If the value for the requested path does not exist but a default value
      * has been specified, this will still return false.
      *
      * @param path Path to check for existence.
      * @return True if this section contains the requested path, regardless of
-     *     having a default.
-     * @throws IllegalArgumentException Thrown when path is null.
+     * having a default.
+     * @throws IllegalArgumentException Thrown when path is {@code null}.
      */
-    public boolean isSet(String path);
+    boolean isSet(String path);
 
     /**
      * Gets the path of this {@link ConfigurationSection} from its root {@link
-     * Configuration}
-     * <p>
-     * For any {@link Configuration} themselves, this will return an empty
+     * Configuration}.
+     *
+     * <p>For any {@link Configuration} themselves, this will return an empty
      * string.
-     * <p>
-     * If the section is no longer contained within its root for any reason,
-     * such as being replaced with a different value, this may return null.
-     * <p>
-     * To retrieve the single name of this section, that is, the final part of
-     * the path returned by this method, you may use {@link #getName()}.
+     *
+     * <p>If the section is no longer contained within its root for any reason,
+     * such as being replaced with a different value,
+     * this may return {@code null}.
+     *
+     * <p>To retrieve the single name of this section, that is, the final part
+     * of the path returned by this method, you may use {@link #getName()}.
      *
      * @return Path of this section relative to its root
      */
-    public String getCurrentPath();
+    String getCurrentPath();
 
     /**
      * Gets the name of this individual {@link ConfigurationSection}, in the
      * path.
-     * <p>
-     * This will always be the final part of {@link #getCurrentPath()}, unless
+     *
+     * <p>This will always be the final part of {@link #getCurrentPath()}, unless
      * the section is orphaned.
      *
      * @return Name of this section
      */
-    public String getName();
+    String getName();
 
     /**
      * Gets the root {@link Configuration} that contains this {@link
      * ConfigurationSection}
-     * <p>
-     * For any {@link Configuration} themselves, this will return its own
+     *
+     * <p>For any {@link Configuration} themselves, this will return its own
      * object.
-     * <p>
-     * If the section is no longer contained within its root for any reason,
-     * such as being replaced with a different value, this may return null.
+     *
+     * <p>If the section is no longer contained within its root for any reason,
+     * such as being replaced with a different value,
+     * this may return {@code null}.
      *
      * @return Root configuration containing this section.
      */
-    public Configuration getRoot();
+    Configuration getRoot();
 
     /**
      * Gets the parent {@link ConfigurationSection} that directly contains
      * this {@link ConfigurationSection}.
-     * <p>
-     * For any {@link Configuration} themselves, this will return null.
-     * <p>
-     * If the section is no longer contained within its parent for any reason,
-     * such as being replaced with a different value, this may return null.
+     *
+     * <p>For any {@link Configuration} themselves, this will return
+     * {@code null}.
+     *
+     * <p>If the section is no longer contained within its parent for any
+     * reason, such as being replaced with a different value, this may
+     * return {@code null}.
      *
      * @return Parent section containing this section.
      */
-    public ConfigurationSection getParent();
+    ConfigurationSection getParent();
 
     /**
      * Gets the requested Object by path.
-     * <p>
-     * If the Object does not exist but a default value has been specified,
+     *
+     * <p>If the Object does not exist but a default value has been specified,
      * this will return the default value. If the Object does not exist and no
-     * default value was specified, this will return null.
+     * default value was specified, this will return {@code null}.
      *
      * @param path Path of the Object to get.
      * @return Requested Object.
      */
-    public Object get(String path);
+    Object get(String path);
 
     /**
      * Gets the requested Object by path, returning a default value if not
      * found.
-     * <p>
-     * If the Object does not exist then the specified default value will
+     *
+     * <p>If the Object does not exist then the specified default value will
      * returned regardless of if a default has been identified in the root
      * {@link Configuration}.
      *
-     * @param path Path of the Object to get.
-     * @param def The default value to return if the path is not found.
+     * @param path         Path of the Object to get.
+     * @param defaultValue The default value to return if the path is not found.
      * @return Requested Object.
      */
-    public Object get(String path, Object def);
+    Object get(String path, Object defaultValue);
 
     /**
      * Sets the specified path to the given value.
-     * <p>
-     * If value is null, the entry will be removed. Any existing entry will be
-     * replaced, regardless of what the new value is.
-     * <p>
-     * Some implementations may have limitations on what you may store. See
-     * their individual javadocs for details. No implementations should allow
-     * you to store {@link Configuration}s or {@link ConfigurationSection}s,
-     * please use {@link #createSection(java.lang.String)} for that.
      *
-     * @param path Path of the object to set.
+     * <p>If value is {@code null}, the entry will be removed. Any
+     * existing entry will be replaced, regardless of what the new value is.
+     *
+     * <p>Some implementations may have limitations on what you may store. See
+     * their individual javadoc for details. No implementations should allow
+     * you to store {@link Configuration}s or {@link ConfigurationSection}s,
+     * please use {@link #createSection(String)} for that.
+     *
+     * @param path  Path of the object to set.
      * @param value New value to set the path to.
      */
-    public void set(String path, Object value);
+    void set(String path, Object value);
 
     /**
      * Creates an empty {@link ConfigurationSection} at the specified path.
-     * <p>
-     * Any value that was previously set at this path will be overwritten. If
+     *
+     * <p>Any value that was previously set at this path will be overwritten. If
      * the previous value was itself a {@link ConfigurationSection}, it will
      * be orphaned.
      *
      * @param path Path to create the section at.
      * @return Newly created section
      */
-    public ConfigurationSection createSection(String path);
+    ConfigurationSection createSection(String path);
 
     /**
      * Creates a {@link ConfigurationSection} at the specified path, with
      * specified values.
-     * <p>
-     * Any value that was previously set at this path will be overwritten. If
+     *
+     * <p>Any value that was previously set at this path will be overwritten. If
      * the previous value was itself a {@link ConfigurationSection}, it will
      * be orphaned.
      *
      * @param path Path to create the section at.
-     * @param map The values to used.
+     * @param map  The values to used.
      * @return Newly created section
      */
-    public ConfigurationSection createSection(String path, Map<?, ?> map);
+    ConfigurationSection createSection(String path, Map<?, ?> map);
 
     // Primitives
+
     /**
      * Gets the requested String by path.
-     * <p>
-     * If the String does not exist but a default value has been specified,
+     *
+     * <p>If the String does not exist but a default value has been specified,
      * this will return the default value. If the String does not exist and no
-     * default value was specified, this will return null.
+     * default value was specified, this will return {@code null}.
      *
      * @param path Path of the String to get.
      * @return Requested String.
      */
-    public String getString(String path);
+    String getString(String path);
 
     /**
      * Gets the requested String by path, returning a default value if not
      * found.
-     * <p>
-     * If the String does not exist then the specified default value will
+     *
+     * <p>If the String does not exist then the specified default value will
      * returned regardless of if a default has been identified in the root
      * {@link Configuration}.
      *
      * @param path Path of the String to get.
-     * @param def The default value to return if the path is not found or is
-     *     not a String.
+     * @param def  The default value to return if the path is not found or is
+     *             not a String.
      * @return Requested String.
      */
-    public String getString(String path, String def);
+    String getString(String path, String def);
 
     /**
      * Checks if the specified path is a String.
-     * <p>
-     * If the path exists but is not a String, this will return false. If the
-     * path does not exist, this will return false. If the path does not exist
-     * but a default value has been specified, this will check if that default
-     * value is a String and return appropriately.
+     *
+     * <p>If the path exists but is not a String, this will return false. If
+     * the path does not exist, this will return false. If the path does not
+     * exist but a default value has been specified, this will check if that
+     * defaultvalue is a String and return appropriately.
      *
      * @param path Path of the String to check.
      * @return Whether or not the specified path is a String.
      */
-    public boolean isString(String path);
+    boolean isString(String path);
 
     /**
      * Gets the requested int by path.
-     * <p>
-     * If the int does not exist but a default value has been specified, this
+     *
+     * <p>If the int does not exist but a default value has been specified, this
      * will return the default value. If the int does not exist and no default
      * value was specified, this will return 0.
      *
      * @param path Path of the int to get.
      * @return Requested int.
      */
-    public int getInt(String path);
+    int getInt(String path);
 
     /**
      * Gets the requested int by path, returning a default value if not found.
-     * <p>
-     * If the int does not exist then the specified default value will
+     *
+     * <p>If the int does not exist then the specified default value will
      * returned regardless of if a default has been identified in the root
      * {@link Configuration}.
      *
      * @param path Path of the int to get.
-     * @param def The default value to return if the path is not found or is
-     *     not an int.
+     * @param def  The default value to return if the path is not found or is
+     *             not an int.
      * @return Requested int.
      */
-    public int getInt(String path, int def);
+    int getInt(String path, int def);
 
     /**
      * Checks if the specified path is an int.
-     * <p>
-     * If the path exists but is not a int, this will return false. If the
+     *
+     * <p>If the path exists but is not a int, this will return false. If the
      * path does not exist, this will return false. If the path does not exist
      * but a default value has been specified, this will check if that default
      * value is a int and return appropriately.
@@ -268,39 +274,39 @@ public interface ConfigurationSection {
      * @param path Path of the int to check.
      * @return Whether or not the specified path is an int.
      */
-    public boolean isInt(String path);
+    boolean isInt(String path);
 
     /**
      * Gets the requested boolean by path.
-     * <p>
-     * If the boolean does not exist but a default value has been specified,
+     *
+     * <p>If the boolean does not exist but a default value has been specified,
      * this will return the default value. If the boolean does not exist and
      * no default value was specified, this will return false.
      *
      * @param path Path of the boolean to get.
      * @return Requested boolean.
      */
-    public boolean getBoolean(String path);
+    boolean getBoolean(String path);
 
     /**
      * Gets the requested boolean by path, returning a default value if not
      * found.
-     * <p>
-     * If the boolean does not exist then the specified default value will
+     *
+     * <p>If the boolean does not exist then the specified default value will
      * returned regardless of if a default has been identified in the root
      * {@link Configuration}.
      *
-     * @param path Path of the boolean to get.
-     * @param def The default value to return if the path is not found or is
-     *     not a boolean.
+     * @param path         Path of the boolean to get.
+     * @param defaultValue The default value to return if the path is not found or is
+     *                     not a boolean.
      * @return Requested boolean.
      */
-    public boolean getBoolean(String path, boolean def);
+    boolean getBoolean(String path, boolean defaultValue);
 
     /**
      * Checks if the specified path is a boolean.
-     * <p>
-     * If the path exists but is not a boolean, this will return false. If the
+     *
+     * <p>If the path exists but is not a boolean, this will return false. If the
      * path does not exist, this will return false. If the path does not exist
      * but a default value has been specified, this will check if that default
      * value is a boolean and return appropriately.
@@ -308,39 +314,39 @@ public interface ConfigurationSection {
      * @param path Path of the boolean to check.
      * @return Whether or not the specified path is a boolean.
      */
-    public boolean isBoolean(String path);
+    boolean isBoolean(String path);
 
     /**
      * Gets the requested double by path.
-     * <p>
-     * If the double does not exist but a default value has been specified,
+     *
+     * <p>If the double does not exist but a default value has been specified,
      * this will return the default value. If the double does not exist and no
      * default value was specified, this will return 0.
      *
      * @param path Path of the double to get.
      * @return Requested double.
      */
-    public double getDouble(String path);
+    double getDouble(String path);
 
     /**
      * Gets the requested double by path, returning a default value if not
      * found.
-     * <p>
-     * If the double does not exist then the specified default value will
+     *
+     * <p>If the double does not exist then the specified default value will
      * returned regardless of if a default has been identified in the root
      * {@link Configuration}.
      *
-     * @param path Path of the double to get.
-     * @param def The default value to return if the path is not found or is
-     *     not a double.
+     * @param path         Path of the double to get.
+     * @param defaultValue The default value to return if the path is not found or is
+     *                     not a double.
      * @return Requested double.
      */
-    public double getDouble(String path, double def);
+    double getDouble(String path, double defaultValue);
 
     /**
      * Checks if the specified path is a double.
-     * <p>
-     * If the path exists but is not a double, this will return false. If the
+     *
+     * <p>If the path exists but is not a double, this will return false. If the
      * path does not exist, this will return false. If the path does not exist
      * but a default value has been specified, this will check if that default
      * value is a double and return appropriately.
@@ -348,39 +354,39 @@ public interface ConfigurationSection {
      * @param path Path of the double to check.
      * @return Whether or not the specified path is a double.
      */
-    public boolean isDouble(String path);
+    boolean isDouble(String path);
 
     /**
      * Gets the requested long by path.
-     * <p>
-     * If the long does not exist but a default value has been specified, this
+     *
+     * <p>If the long does not exist but a default value has been specified, this
      * will return the default value. If the long does not exist and no
      * default value was specified, this will return 0.
      *
      * @param path Path of the long to get.
      * @return Requested long.
      */
-    public long getLong(String path);
+    long getLong(String path);
 
     /**
      * Gets the requested long by path, returning a default value if not
      * found.
-     * <p>
-     * If the long does not exist then the specified default value will
+     *
+     * <p>If the long does not exist then the specified default value will
      * returned regardless of if a default has been identified in the root
      * {@link Configuration}.
      *
      * @param path Path of the long to get.
-     * @param def The default value to return if the path is not found or is
-     *     not a long.
+     * @param def  The default value to return if the path is not found or is
+     *             not a long.
      * @return Requested long.
      */
-    public long getLong(String path, long def);
+    long getLong(String path, long def);
 
     /**
      * Checks if the specified path is a long.
-     * <p>
-     * If the path exists but is not a long, this will return false. If the
+     *
+     * <p>If the path exists but is not a long, this will return false. If the
      * path does not exist, this will return false. If the path does not exist
      * but a default value has been specified, this will check if that default
      * value is a long and return appropriately.
@@ -388,40 +394,41 @@ public interface ConfigurationSection {
      * @param path Path of the long to check.
      * @return Whether or not the specified path is a long.
      */
-    public boolean isLong(String path);
+    boolean isLong(String path);
 
     // Java
+
     /**
      * Gets the requested List by path.
-     * <p>
-     * If the List does not exist but a default value has been specified, this
+     *
+     * <p>If the List does not exist but a default value has been specified, this
      * will return the default value. If the List does not exist and no
      * default value was specified, this will return null.
      *
      * @param path Path of the List to get.
      * @return Requested List.
      */
-    public List<?> getList(String path);
+    List<?> getList(String path);
 
     /**
      * Gets the requested List by path, returning a default value if not
      * found.
-     * <p>
-     * If the List does not exist then the specified default value will
+     *
+     * <p>If the List does not exist then the specified default value will
      * returned regardless of if a default has been identified in the root
      * {@link Configuration}.
      *
      * @param path Path of the List to get.
-     * @param def The default value to return if the path is not found or is
-     *     not a List.
+     * @param def  The default value to return if the path is not found or is
+     *             not a List.
      * @return Requested List.
      */
-    public List<?> getList(String path, List<?> def);
+    List<?> getList(String path, List<?> def);
 
     /**
      * Checks if the specified path is a List.
-     * <p>
-     * If the path exists but is not a List, this will return false. If the
+     *
+     * <p>If the path exists but is not a List, this will return false. If the
      * path does not exist, this will return false. If the path does not exist
      * but a default value has been specified, this will check if that default
      * value is a List and return appropriately.
@@ -429,175 +436,174 @@ public interface ConfigurationSection {
      * @param path Path of the List to check.
      * @return Whether or not the specified path is a List.
      */
-    public boolean isList(String path);
+    boolean isList(String path);
 
     /**
      * Gets the requested List of String by path.
-     * <p>
-     * If the List does not exist but a default value has been specified, this
-     * will return the default value. If the List does not exist and no
+     *
+     * <p>If the List does not exist but a default value has been specified,
+     * this will return the default value. If the List does not exist and no
      * default value was specified, this will return an empty List.
-     * <p>
-     * This method will attempt to cast any values into a String if possible,
+     *
+     * <p>This method will attempt to cast any values into a String if possible,
      * but may miss any values out if they are not compatible.
      *
      * @param path Path of the List to get.
      * @return Requested List of String.
      */
-    public List<String> getStringList(String path);
+    List<String> getStringList(String path);
 
     /**
      * Gets the requested List of Integer by path.
-     * <p>
-     * If the List does not exist but a default value has been specified, this
-     * will return the default value. If the List does not exist and no
+     *
+     * <p>If the List does not exist but a default value has been specified,
+     * this will return the default value. If the List does not exist and no
      * default value was specified, this will return an empty List.
-     * <p>
-     * This method will attempt to cast any values into a Integer if possible,
-     * but may miss any values out if they are not compatible.
+     *
+     * <p>This method will attempt to cast any values into a Integer if
+     * possible, but may miss any values out if they are not compatible.
      *
      * @param path Path of the List to get.
      * @return Requested List of Integer.
      */
-    public List<Integer> getIntegerList(String path);
+    List<Integer> getIntegerList(String path);
 
     /**
      * Gets the requested List of Boolean by path.
-     * <p>
-     * If the List does not exist but a default value has been specified, this
-     * will return the default value. If the List does not exist and no
+     *
+     * <p>If the List does not exist but a default value has been specified,
+     * this will return the default value. If the List does not exist and no
      * default value was specified, this will return an empty List.
-     * <p>
-     * This method will attempt to cast any values into a Boolean if possible,
-     * but may miss any values out if they are not compatible.
+     *
+     * <p>This method will attempt to cast any values into a Boolean if
+     * possible, but may miss any values out if they are not compatible.
      *
      * @param path Path of the List to get.
      * @return Requested List of Boolean.
      */
-    public List<Boolean> getBooleanList(String path);
+    List<Boolean> getBooleanList(String path);
 
     /**
      * Gets the requested List of Double by path.
-     * <p>
-     * If the List does not exist but a default value has been specified, this
-     * will return the default value. If the List does not exist and no
+     *
+     * <p>If the List does not exist but a default value has been specified,
+     * this will return the default value. If the List does not exist and no
      * default value was specified, this will return an empty List.
-     * <p>
-     * This method will attempt to cast any values into a Double if possible,
+     *
+     * <p>This method will attempt to cast any values into a Double if possible,
      * but may miss any values out if they are not compatible.
      *
      * @param path Path of the List to get.
      * @return Requested List of Double.
      */
-    public List<Double> getDoubleList(String path);
+    List<Double> getDoubleList(String path);
 
     /**
      * Gets the requested List of Float by path.
-     * <p>
-     * If the List does not exist but a default value has been specified, this
-     * will return the default value. If the List does not exist and no
+     *
+     * <p>If the List does not exist but a default value has been specified,
+     * this will return the default value. If the List does not exist and no
      * default value was specified, this will return an empty List.
-     * <p>
-     * This method will attempt to cast any values into a Float if possible,
+     *
+     * <p>This method will attempt to cast any values into a Float if possible,
      * but may miss any values out if they are not compatible.
      *
      * @param path Path of the List to get.
      * @return Requested List of Float.
      */
-    public List<Float> getFloatList(String path);
+    List<Float> getFloatList(String path);
 
     /**
      * Gets the requested List of Long by path.
-     * <p>
-     * If the List does not exist but a default value has been specified, this
-     * will return the default value. If the List does not exist and no
+     *
+     * <p>If the List does not exist but a default value has been specified,
+     * this will return the default value. If the List does not exist and no
      * default value was specified, this will return an empty List.
-     * <p>
-     * This method will attempt to cast any values into a Long if possible,
+     *
+     * <p>This method will attempt to cast any values into a Long if possible,
      * but may miss any values out if they are not compatible.
      *
      * @param path Path of the List to get.
      * @return Requested List of Long.
      */
-    public List<Long> getLongList(String path);
+    List<Long> getLongList(String path);
 
     /**
      * Gets the requested List of Byte by path.
-     * <p>
-     * If the List does not exist but a default value has been specified, this
-     * will return the default value. If the List does not exist and no
+     *
+     * <p>If the List does not exist but a default value has been specified,
+     * this will return the default value. If the List does not exist and no
      * default value was specified, this will return an empty List.
-     * <p>
-     * This method will attempt to cast any values into a Byte if possible,
+     *
+     * <p>This method will attempt to cast any values into a Byte if possible,
      * but may miss any values out if they are not compatible.
      *
      * @param path Path of the List to get.
      * @return Requested List of Byte.
      */
-    public List<Byte> getByteList(String path);
+    List<Byte> getByteList(String path);
 
     /**
      * Gets the requested List of Character by path.
-     * <p>
-     * If the List does not exist but a default value has been specified, this
-     * will return the default value. If the List does not exist and no
+     *
+     * <p>If the List does not exist but a default value has been specified,
+     * this will return the default value. If the List does not exist and no
      * default value was specified, this will return an empty List.
-     * <p>
-     * This method will attempt to cast any values into a Character if
+     *
+     * <p>This method will attempt to cast any values into a Character if
      * possible, but may miss any values out if they are not compatible.
      *
      * @param path Path of the List to get.
      * @return Requested List of Character.
      */
-    public List<Character> getCharacterList(String path);
+    List<Character> getCharacterList(String path);
 
     /**
      * Gets the requested List of Short by path.
-     * <p>
-     * If the List does not exist but a default value has been specified, this
-     * will return the default value. If the List does not exist and no
+     *
+     * <p>If the List does not exist but a default value has been specified,
+     * this will return the default value. If the List does not exist and no
      * default value was specified, this will return an empty List.
-     * <p>
-     * This method will attempt to cast any values into a Short if possible,
-     * but may miss any values out if they are not compatible.
+     *
+     * <p>This method will attempt to cast any values into a Short if
+     * possible, but may miss any values out if they are not compatible.
      *
      * @param path Path of the List to get.
      * @return Requested List of Short.
      */
-    public List<Short> getShortList(String path);
+    List<Short> getShortList(String path);
 
     /**
      * Gets the requested List of Maps by path.
-     * <p>
-     * If the List does not exist but a default value has been specified, this
-     * will return the default value. If the List does not exist and no
+     *
+     * <p>If the List does not exist but a default value has been specified,
+     * this will return the default value. If the List does not exist and no
      * default value was specified, this will return an empty List.
-     * <p>
-     * This method will attempt to cast any values into a Map if possible, but
-     * may miss any values out if they are not compatible.
+     * <p>This method will attempt to cast any values into a Map if possible,
+     * but may miss any values out if they are not compatible.
      *
      * @param path Path of the List to get.
      * @return Requested List of Maps.
      */
-    public List<Map<?, ?>> getMapList(String path);
+    List<Map<?, ?>> getMapList(String path);
 
     /**
      * Gets the requested ConfigurationSection by path.
-     * <p>
-     * If the ConfigurationSection does not exist but a default value has been
-     * specified, this will return the default value. If the
+     *
+     * <p>If the ConfigurationSection does not exist but a default value has
+     * been specified, this will return the default value. If the
      * ConfigurationSection does not exist and no default value was specified,
-     * this will return null.
+     * this will return {@code null}.
      *
      * @param path Path of the ConfigurationSection to get.
      * @return Requested ConfigurationSection.
      */
-    public ConfigurationSection getConfigurationSection(String path);
+    ConfigurationSection getConfigurationSection(String path);
 
     /**
      * Checks if the specified path is a ConfigurationSection.
-     * <p>
-     * If the path exists but is not a ConfigurationSection, this will return
+     *
+     * <p>If the path exists but is not a ConfigurationSection, this will return
      * false. If the path does not exist, this will return false. If the path
      * does not exist but a default value has been specified, this will check
      * if that default value is a ConfigurationSection and return
@@ -606,37 +612,37 @@ public interface ConfigurationSection {
      * @param path Path of the ConfigurationSection to check.
      * @return Whether or not the specified path is a ConfigurationSection.
      */
-    public boolean isConfigurationSection(String path);
+    boolean isConfigurationSection(String path);
 
     /**
      * Gets the equivalent {@link ConfigurationSection} from the default
      * {@link Configuration} defined in {@link #getRoot()}.
-     * <p>
-     * If the root contains no defaults, or the defaults doesn't contain a
+     *
+     * <p>If the root contains no defaults, or the defaults doesn't contain a
      * value for this path, or the value at this path is not a {@link
-     * ConfigurationSection} then this will return null.
+     * ConfigurationSection} then this will return {@code null}.
      *
      * @return Equivalent section in root configuration
      */
-    public ConfigurationSection getDefaultSection();
+    ConfigurationSection getDefaultSection();
 
     /**
      * Sets the default value in the root at the given path as provided.
-     * <p>
-     * If no source {@link Configuration} was provided as a default
+     *
+     * <p>If no source {@link Configuration} was provided as a default
      * collection, then a new {@link MemoryConfiguration} will be created to
      * hold the new default value.
-     * <p>
-     * If value is null, the value will be removed from the default
-     * Configuration source.
-     * <p>
-     * If the value as returned by {@link #getDefaultSection()} is null, then
-     * this will create a new section at the path, replacing anything that may
-     * have existed there previously.
      *
-     * @param path Path of the value to set.
-     * @param value Value to set the default to.
-     * @throws IllegalArgumentException Thrown if path is null.
+     * <p>If value is {@code null}, the value will be removed from the
+     * default Configuration source.
+     *
+     * <p>If the value as returned by {@link #getDefaultSection()} is
+     * {@code null}, then this will create a new section at the path,
+     * replacing anything that may have existed there previously.
+     *
+     * @param path  Path of the value to set
+     * @param value Value to set the default to
+     * @throws IllegalArgumentException Thrown if path is {@code null}
      */
-    public void addDefault(String path, Object value);
+    void addDefault(String path, Object value);
 }

Core/src/main/java/com/github/intellectualsites/plotsquared/configuration/InvalidConfigurationException.java

@@ -1,16 +1,16 @@
-package com.intellectualcrafters.configuration;
+package com.github.intellectualsites.plotsquared.configuration;
 
 /**
- * Exception thrown when attempting to load an invalid {@link Configuration}
+ * Exception thrown when attempting to load an invalid {@link Configuration}.
  */
-@SuppressWarnings("serial")
-public class InvalidConfigurationException extends Exception {
+@SuppressWarnings("serial") public class InvalidConfigurationException extends Exception {
 
     /**
      * Creates a new instance of InvalidConfigurationException without a
      * message or cause.
      */
-    public InvalidConfigurationException() {}
+    public InvalidConfigurationException() {
+    }
 
     /**
      * Constructs an instance of InvalidConfigurationException with the
@@ -37,7 +37,7 @@ public class InvalidConfigurationException extends Exception {
      * specified message and cause.
      *
      * @param cause The cause of the exception.
-     * @param msg The details of the exception.
+     * @param msg   The details of the exception.
      */
     public InvalidConfigurationException(String msg, Throwable cause) {
         super(msg, cause);

Core/src/main/java/com/github/intellectualsites/plotsquared/configuration/MemoryConfiguration.java

@@ -1,4 +1,4 @@
-package com.intellectualcrafters.configuration;
+package com.github.intellectualsites.plotsquared.configuration;
 
 import java.util.Map;
 
@@ -14,7 +14,8 @@ public class MemoryConfiguration extends MemorySection implements Configuration
     /**
      * Creates an empty {@link MemoryConfiguration} with no default values.
      */
-    public MemoryConfiguration() {}
+    public MemoryConfiguration() {
+    }
 
     /**
      * Creates an empty {@link MemoryConfiguration} using the specified {@link
@@ -27,50 +28,45 @@ public class MemoryConfiguration extends MemorySection implements Configuration
         this.defaults = defaults;
     }
 
-    @Override
-    public void addDefault(String path, Object value) {
-        if (path == null) throw new NullPointerException("Path may not be null");
-        if (defaults == null) {
-            defaults = new MemoryConfiguration();
+    @Override public void addDefault(String path, Object value) {
+        if (this.defaults == null) {
+            this.defaults = new MemoryConfiguration();
         }
 
-        defaults.set(path, value);
+        this.defaults.set(path, value);
     }
 
-    public void addDefaults(Map<String, Object> defaults) {
-        if (defaults == null) throw new NullPointerException("Defaults may not be null");
-
+    @Override public void addDefaults(Map<String, Object> defaults) {
         for (Map.Entry<String, Object> entry : defaults.entrySet()) {
             addDefault(entry.getKey(), entry.getValue());
         }
     }
 
-    public void addDefaults(Configuration defaults) {
-        if (defaults == null) throw new NullPointerException("Defaults may not be null");
-
+    @Override public void addDefaults(Configuration defaults) {
         addDefaults(defaults.getValues(true));
     }
 
-    public void setDefaults(Configuration defaults) {
-        if (defaults == null) throw new NullPointerException("Defaults may not be null");
+    @Override public Configuration getDefaults() {
+        return this.defaults;
+    }
+
+    @Override public void setDefaults(Configuration defaults) {
+        if (defaults == null) {
+            throw new NullPointerException("Defaults may not be null");
+        }
 
         this.defaults = defaults;
     }
 
-    public Configuration getDefaults() {
-        return defaults;
-    }
-
-    @Override
-    public ConfigurationSection getParent() {
+    @Override public ConfigurationSection getParent() {
         return null;
     }
 
-    public MemoryConfigurationOptions options() {
-        if (options == null) {
-            options = new MemoryConfigurationOptions(this);
+    @Override public MemoryConfigurationOptions options() {
+        if (this.options == null) {
+            this.options = new MemoryConfigurationOptions(this);
         }
 
-        return options;
+        return this.options;
     }
 }

Core/src/main/java/com/github/intellectualsites/plotsquared/configuration/MemoryConfigurationOptions.java

@@ -1,28 +1,21 @@
-package com.intellectualcrafters.configuration;
+package com.github.intellectualsites.plotsquared.configuration;
 
 /**
  * Various settings for controlling the input and output of a {@link
- * MemoryConfiguration}
+ * MemoryConfiguration}.
  */
 public class MemoryConfigurationOptions extends ConfigurationOptions {
     protected MemoryConfigurationOptions(MemoryConfiguration configuration) {
         super(configuration);
     }
 
-    @Override
-    public MemoryConfiguration configuration() {
+    @Override public MemoryConfiguration configuration() {
         return (MemoryConfiguration) super.configuration();
     }
 
-    @Override
-    public MemoryConfigurationOptions copyDefaults(boolean value) {
+    @Override public MemoryConfigurationOptions copyDefaults(boolean value) {
         super.copyDefaults(value);
         return this;
     }
 
-    @Override
-    public MemoryConfigurationOptions pathSeparator(char value) {
-        super.pathSeparator(value);
-        return this;
-    }
 }

Core/src/main/java/com/github/intellectualsites/plotsquared/configuration/MemorySection.java

@@ -1,4 +1,4 @@
-package com.intellectualcrafters.configuration;
+package com.github.intellectualsites.plotsquared.configuration;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -11,82 +11,27 @@ import java.util.Set;
  * A type of {@link ConfigurationSection} that is stored in memory.
  */
 public class MemorySection implements ConfigurationSection {
-    protected final Map<String, Object> map = new LinkedHashMap<String, Object>();
+
+    protected final Map<String, Object> map = new LinkedHashMap<>();
     private final Configuration root;
     private final ConfigurationSection parent;
     private final String path;
     private final String fullPath;
 
-    public static double toDouble(Object obj, double def) {
-        if (obj instanceof Number) {
-            return ((Number) obj).doubleValue();
-        }
-        if (obj instanceof String) {
-            try {
-                return Double.parseDouble((String) obj);
-            }
-            catch (Exception e) {}
-        }
-        else if (obj instanceof List) {
-            List<?> val = ((List<?>) obj);
-            if (val.size() > 0) {
-                return toDouble(val.get(0), def);
-            }
-        }
-        return def;
-    }
-    
-    public static int toInt(Object obj, int def) {
-        if (obj instanceof Number) {
-            return ((Number) obj).intValue();
-        }
-        if (obj instanceof String) {
-            try {
-                return Integer.parseInt((String) obj);
-            }
-            catch (Exception e) {}
-        }
-        else if (obj instanceof List) {
-            List<?> val = ((List<?>) obj);
-            if (val.size() > 0) {
-                return toInt(val.get(0), def);
-            }
-        }
-        return def;
-    }
-    
-    public static long toLong(Object obj, long def) {
-        if (obj instanceof Number) {
-            return ((Number) obj).longValue();
-        }
-        if (obj instanceof String) {
-            try {
-                return Long.parseLong((String) obj);
-            }
-            catch (Exception e) {}
-        }
-        else if (obj instanceof List) {
-            List<?> val = ((List<?>) obj);
-            if (val.size() > 0) {
-                return toLong(val.get(0), def);
-            }
-        }
-        return def;
-    }
-    
     /**
      * Creates an empty MemorySection for use as a root {@link Configuration}
      * section.
-     * <p>
-     * Note that calling this without being yourself a {@link Configuration}
+     *
+     * <p>Note that calling this without being yourself a {@link Configuration}
      * will throw an exception!
      *
      * @throws IllegalStateException Thrown if this is not a {@link
-     *     Configuration} root.
+     *                               Configuration} root.
      */
     protected MemorySection() {
         if (!(this instanceof Configuration)) {
-            throw new IllegalStateException("Cannot construct a root MemorySection when not a Configuration");
+            throw new IllegalStateException(
+                "Cannot construct a root MemorySection when not a Configuration");
         }
 
         this.path = "";
@@ -99,29 +44,138 @@ public class MemorySection implements ConfigurationSection {
      * Creates an empty MemorySection with the specified parent and path.
      *
      * @param parent Parent section that contains this own section.
-     * @param path Path that you may access this section from via the root
-     *     {@link Configuration}.
+     * @param path   Path that you may access this section from via the root
+     *               {@link Configuration}.
      * @throws IllegalArgumentException Thrown is parent or path is null, or
-     *     if parent contains no root Configuration.
+     *                                  if parent contains no root Configuration.
      */
     protected MemorySection(ConfigurationSection parent, String path) {
-        if (parent == null) throw new NullPointerException("Parent may not be null");
-        if (path == null) throw new NullPointerException("Path may not be null");
-
         this.path = path;
         this.parent = parent;
         this.root = parent.getRoot();
 
-        if (root == null) throw new NullPointerException("Path may not be orphaned");
+        if (this.root == null) {
+            throw new NullPointerException("Path may not be orphaned");
+        }
 
         this.fullPath = createPath(parent, path);
     }
 
-    public Set<String> getKeys(boolean deep) {
-        Set<String> result = new LinkedHashSet<String>();
+    public static double toDouble(Object obj, double def) {
+        if (obj instanceof Number) {
+            return ((Number) obj).doubleValue();
+        }
+        if (obj instanceof String) {
+            try {
+                return Double.parseDouble((String) obj);
+            } catch (NumberFormatException ignored) {
+            }
+        } else if (obj instanceof List) {
+            List<?> val = (List<?>) obj;
+            if (!val.isEmpty()) {
+                return toDouble(val.get(0), def);
+            }
+        }
+        return def;
+    }
+
+    public static int toInt(Object obj, int def) {
+        if (obj instanceof Number) {
+            return ((Number) obj).intValue();
+        }
+        if (obj instanceof String) {
+            try {
+                return Integer.parseInt((String) obj);
+            } catch (NumberFormatException ignored) {
+            }
+        } else if (obj instanceof List) {
+            List<?> val = (List<?>) obj;
+            if (!val.isEmpty()) {
+                return toInt(val.get(0), def);
+            }
+        }
+        return def;
+    }
+
+    public static long toLong(Object obj, long def) {
+        if (obj instanceof Number) {
+            return ((Number) obj).longValue();
+        }
+        if (obj instanceof String) {
+            try {
+                return Long.parseLong((String) obj);
+            } catch (NumberFormatException ignored) {
+            }
+        } else if (obj instanceof List) {
+            List<?> val = (List<?>) obj;
+            if (!val.isEmpty()) {
+                return toLong(val.get(0), def);
+            }
+        }
+        return def;
+    }
+
+    /**
+     * Creates a full path to the given {@link ConfigurationSection} from its
+     * root {@link Configuration}.
+     *
+     * <p>You may use this method for any given {@link ConfigurationSection}, not
+     * only {@link MemorySection}.
+     *
+     * @param section Section to create a path for.
+     * @param key     Name of the specified section.
+     * @return Full path of the section from its root.
+     */
+    public static String createPath(ConfigurationSection section, String key) {
+        return createPath(section, key, section.getRoot());
+    }
+
+    /**
+     * Creates a relative path to the given {@link ConfigurationSection} from
+     * the given relative section.
+     *
+     * <p>You may use this method for any given {@link ConfigurationSection}, not
+     * only {@link MemorySection}.
+     *
+     * @param section    Section to create a path for.
+     * @param key        Name of the specified section.
+     * @param relativeTo Section to create the path relative to.
+     * @return Full path of the section from its root.
+     */
+    public static String createPath(ConfigurationSection section, String key,
+        ConfigurationSection relativeTo) {
+        Configuration root = section.getRoot();
+        if (root == null) {
+            throw new IllegalStateException("Cannot create path without a root");
+        }
+        char separator = root.options().pathSeparator();
+
+        StringBuilder builder = new StringBuilder();
+        for (ConfigurationSection parent = section;
+             (parent != null) && (parent != relativeTo); parent = parent.getParent()) {
+            if (builder.length() > 0) {
+                builder.insert(0, separator);
+            }
+
+            builder.insert(0, parent.getName());
+        }
+
+        if ((key != null) && !key.isEmpty()) {
+            if (builder.length() > 0) {
+                builder.append(separator);
+            }
+
+            builder.append(key);
+        }
+
+        return builder.toString();
+    }
+
+    @Override public Set<String> getKeys(boolean deep) {
+        Set<String> result = new LinkedHashSet<>();
 
         Configuration root = getRoot();
-        if (root != null && root.options().copyDefaults()) {
+        if ((root != null) && root.options().copyDefaults()) {
             ConfigurationSection defaults = getDefaultSection();
 
             if (defaults != null) {
@@ -134,11 +188,11 @@ public class MemorySection implements ConfigurationSection {
         return result;
     }
 
-    public Map<String, Object> getValues(boolean deep) {
-        Map<String, Object> result = new LinkedHashMap<String, Object>();
+    @Override public Map<String, Object> getValues(boolean deep) {
+        Map<String, Object> result = new LinkedHashMap<>();
 
         Configuration root = getRoot();
-        if (root != null && root.options().copyDefaults()) {
+        if ((root != null) && root.options().copyDefaults()) {
             ConfigurationSection defaults = getDefaultSection();
 
             if (defaults != null) {
@@ -151,11 +205,11 @@ public class MemorySection implements ConfigurationSection {
         return result;
     }
 
-    public boolean contains(String path) {
+    @Override public boolean contains(String path) {
         return get(path) != null;
     }
 
-    public boolean isSet(String path) {
+    @Override public boolean isSet(String path) {
         Configuration root = getRoot();
         if (root == null) {
             return false;
@@ -166,36 +220,35 @@ public class MemorySection implements ConfigurationSection {
         return get(path, null) != null;
     }
 
-    public String getCurrentPath() {
-        return fullPath;
+    @Override public String getCurrentPath() {
+        return this.fullPath;
     }
 
-    public String getName() {
-        return path;
+    @Override public String getName() {
+        return this.path;
     }
 
-    public Configuration getRoot() {
-        return root;
+    @Override public Configuration getRoot() {
+        return this.root;
     }
 
-    public ConfigurationSection getParent() {
-        return parent;
+    @Override public ConfigurationSection getParent() {
+        return this.parent;
     }
 
-    public void addDefault(String path, Object value) {
-        if (path == null) throw new NullPointerException("Path cannot be null");
-
+    @Override public void addDefault(String path, Object value) {
         Configuration root = getRoot();
         if (root == null) {
             throw new IllegalStateException("Cannot add default without root");
         }
         if (root == this) {
-            throw new UnsupportedOperationException("Unsupported addDefault(String, Object) implementation");
+            throw new UnsupportedOperationException(
+                "Unsupported addDefault(String, Object) implementation");
         }
         root.addDefault(createPath(this, path), value);
     }
 
-    public ConfigurationSection getDefaultSection() {
+    @Override public ConfigurationSection getDefaultSection() {
         Configuration root = getRoot();
         Configuration defaults = root == null ? null : root.getDefaults();
 
@@ -208,18 +261,17 @@ public class MemorySection implements ConfigurationSection {
         return null;
     }
 
-    public void set(String path, Object value) {
-        if (path == null) throw new NullPointerException("Cannot set to an empty path");
-
+    @Override public void set(String path, Object value) {
         Configuration root = getRoot();
         if (root == null) {
             throw new IllegalStateException("Cannot use section without a root");
         }
 
-        final char separator = root.options().pathSeparator();
+        char separator = root.options().pathSeparator();
         // i1 is the leading (higher) index
         // i2 is the trailing (lower) index
-        int i1 = -1, i2;
+        int i1 = -1;
+        int i2;
         ConfigurationSection section = this;
         while ((i1 = path.indexOf(separator, i2 = i1 + 1)) != -1) {
             String node = path.substring(i2, i1);
@@ -234,23 +286,25 @@ public class MemorySection implements ConfigurationSection {
         String key = path.substring(i2);
         if (section == this) {
             if (value == null) {
-                map.remove(key);
+                this.map.remove(key);
             } else {
-                map.put(key, value);
+                this.map.put(key, value);
             }
         } else {
             section.set(key, value);
         }
     }
 
-    public Object get(String path) {
+    @Override public Object get(String path) {
         return get(path, getDefault(path));
     }
 
-    public Object get(String path, Object def) {
-        if (path == null) throw new NullPointerException("Path cannot be null");
+    @Override public Object get(String path, Object defaultValue) {
+        if (path == null) {
+            throw new NullPointerException("Path cannot be null");
+        }
 
-        if (path.length() == 0) {
+        if (path.isEmpty()) {
             return this;
         }
 
@@ -259,37 +313,42 @@ public class MemorySection implements ConfigurationSection {
             throw new IllegalStateException("Cannot access section without a root");
         }
 
-        final char separator = root.options().pathSeparator();
+        char separator = root.options().pathSeparator();
         // i1 is the leading (higher) index
         // i2 is the trailing (lower) index
-        int i1 = -1, i2;
+        int i1 = -1;
+        int i2;
         ConfigurationSection section = this;
         while ((i1 = path.indexOf(separator, i2 = i1 + 1)) != -1) {
             section = section.getConfigurationSection(path.substring(i2, i1));
             if (section == null) {
-                return def;
+                return defaultValue;
             }
         }
 
         String key = path.substring(i2);
         if (section == this) {
-            Object result = map.get(key);
-            return (result == null) ? def : result;
+            Object result = this.map.get(key);
+            if (result == null) {
+                return defaultValue;
+            } else {
+                return result;
+            }
         }
-        return section.get(key, def);
+        return section.get(key, defaultValue);
     }
 
-    public ConfigurationSection createSection(String path) {
-        if (path == null) throw new NullPointerException("Cannot create section at empty path");
+    @Override public ConfigurationSection createSection(String path) {
         Configuration root = getRoot();
         if (root == null) {
             throw new IllegalStateException("Cannot create section without a root");
         }
 
-        final char separator = root.options().pathSeparator();
+        char separator = root.options().pathSeparator();
         // i1 is the leading (higher) index
         // i2 is the trailing (lower) index
-        int i1 = -1, i2;
+        int i1 = -1;
+        int i2;
         ConfigurationSection section = this;
         while ((i1 = path.indexOf(separator, i2 = i1 + 1)) != -1) {
             String node = path.substring(i2, i1);
@@ -304,13 +363,13 @@ public class MemorySection implements ConfigurationSection {
         String key = path.substring(i2);
         if (section == this) {
             ConfigurationSection result = new MemorySection(this, key);
-            map.put(key, result);
+            this.map.put(key, result);
             return result;
         }
         return section.createSection(key);
     }
 
-    public ConfigurationSection createSection(String path, Map<?, ?> map) {
+    @Override public ConfigurationSection createSection(String path, Map<?, ?> map) {
         ConfigurationSection section = createSection(path);
 
         for (Map.Entry<?, ?> entry : map.entrySet()) {
@@ -325,108 +384,120 @@ public class MemorySection implements ConfigurationSection {
     }
 
     // Primitives
-    public String getString(String path) {
+    @Override public String getString(String path) {
         Object def = getDefault(path);
         return getString(path, def != null ? def.toString() : null);
     }
 
-    public String getString(String path, String def) {
+    @Override public String getString(String path, String def) {
         Object val = get(path, def);
-        return (val != null) ? val.toString() : def;
+        if (val != null) {
+            return val.toString();
+        } else {
+            return def;
+        }
     }
 
-    public boolean isString(String path) {
+    @Override public boolean isString(String path) {
         Object val = get(path);
         return val instanceof String;
     }
 
-    public int getInt(String path) {
+    @Override public int getInt(String path) {
         Object def = getDefault(path);
         return getInt(path, toInt(def, 0));
     }
 
-    public int getInt(String path, int def) {
+    @Override public int getInt(String path, int def) {
         Object val = get(path, def);
         return toInt(val, def);
     }
 
-    public boolean isInt(String path) {
+    @Override public boolean isInt(String path) {
         Object val = get(path);
         return val instanceof Integer;
     }
 
-    public boolean getBoolean(String path) {
+    @Override public boolean getBoolean(String path) {
         Object def = getDefault(path);
-        return getBoolean(path, (def instanceof Boolean) ? (Boolean) def : false);
+        if (def instanceof Boolean) {
+            return getBoolean(path, (Boolean) def);
+        } else {
+            return getBoolean(path, false);
+        }
     }
 
-    public boolean getBoolean(String path, boolean def) {
-        Object val = get(path, def);
-        return (val instanceof Boolean) ? (Boolean) val : def;
+    @Override public boolean getBoolean(String path, boolean defaultValue) {
+        Object val = get(path, defaultValue);
+        if (val instanceof Boolean) {
+            return (Boolean) val;
+        } else {
+            return defaultValue;
+        }
     }
 
-    public boolean isBoolean(String path) {
+    @Override public boolean isBoolean(String path) {
         Object val = get(path);
         return val instanceof Boolean;
     }
 
-    public double getDouble(String path) {
+    @Override public double getDouble(String path) {
         Object def = getDefault(path);
         return getDouble(path, toDouble(def, 0));
     }
 
-    public double getDouble(String path, double def) {
-        Object val = get(path, def);
-        return toDouble(val, def);
+    @Override public double getDouble(String path, double defaultValue) {
+        Object val = get(path, defaultValue);
+        return toDouble(val, defaultValue);
     }
 
-    public boolean isDouble(String path) {
+    @Override public boolean isDouble(String path) {
         Object val = get(path);
         return val instanceof Double;
     }
 
-    public long getLong(String path) {
+    @Override public long getLong(String path) {
         Object def = getDefault(path);
         return getLong(path, toLong(def, 0));
     }
 
-    public long getLong(String path, long def) {
+    @Override public long getLong(String path, long def) {
         Object val = get(path, def);
         return toLong(val, def);
     }
 
-    public boolean isLong(String path) {
+    @Override public boolean isLong(String path) {
         Object val = get(path);
         return val instanceof Long;
     }
 
     // Java
-    public List<?> getList(String path) {
+    @Override public List<?> getList(String path) {
         Object def = getDefault(path);
-        return getList(path, (def instanceof List) ? (List<?>) def : null);
+        return getList(path, def instanceof List ? (List<?>) def : null);
     }
 
-    public List<?> getList(String path, List<?> def) {
+    @Override public List<?> getList(String path, List<?> def) {
         Object val = get(path, def);
         return (List<?>) ((val instanceof List) ? val : def);
     }
 
-    public boolean isList(String path) {
+    @Override public boolean isList(String path) {
         Object val = get(path);
         return val instanceof List;
     }
 
-    public List<String> getStringList(String path) {
+    @Override public List<String> getStringList(String path) {
         List<?> list = getList(path);
 
         if (list == null) {
-            return new ArrayList<String>(0);
+            return new ArrayList<>(0);
         }
 
-        List<String> result = new ArrayList<String>();
+        List<String> result = new ArrayList<>();
 
         for (Object object : list) {
-            if ((object instanceof String) || (isPrimitiveWrapper(object))) {
+            if ((object instanceof String) || isPrimitiveWrapper(object)) {
                 result.add(String.valueOf(object));
             }
         }
@@ -434,14 +505,10 @@ public class MemorySection implements ConfigurationSection {
         return result;
     }
 
-    public List<Integer> getIntegerList(String path) {
+    @Override public List<Integer> getIntegerList(String path) {
         List<?> list = getList(path);
 
-        if (list == null) {
-            return new ArrayList<Integer>(0);
-        }
-
-        List<Integer> result = new ArrayList<Integer>();
+        List<Integer> result = new ArrayList<>();
 
         for (Object object : list) {
             if (object instanceof Integer) {
@@ -449,10 +516,10 @@ public class MemorySection implements ConfigurationSection {
             } else if (object instanceof String) {
                 try {
                     result.add(Integer.valueOf((String) object));
-                } catch (Exception ex) {
+                } catch (NumberFormatException ignored) {
                 }
             } else if (object instanceof Character) {
-                result.add((int) ((Character) object).charValue());
+                result.add((int) (Character) object);
             } else if (object instanceof Number) {
                 result.add(((Number) object).intValue());
             }
@@ -461,14 +528,10 @@ public class MemorySection implements ConfigurationSection {
         return result;
     }
 
-    public List<Boolean> getBooleanList(String path) {
+    @Override public List<Boolean> getBooleanList(String path) {
         List<?> list = getList(path);
 
-        if (list == null) {
-            return new ArrayList<Boolean>(0);
-        }
-
-        List<Boolean> result = new ArrayList<Boolean>();
+        List<Boolean> result = new ArrayList<>();
 
         for (Object object : list) {
             if (object instanceof Boolean) {
@@ -485,14 +548,10 @@ public class MemorySection implements ConfigurationSection {
         return result;
     }
 
-    public List<Double> getDoubleList(String path) {
+    @Override public List<Double> getDoubleList(String path) {
         List<?> list = getList(path);
 
-        if (list == null) {
-            return new ArrayList<Double>(0);
-        }
-
-        List<Double> result = new ArrayList<Double>();
+        List<Double> result = new ArrayList<>();
 
         for (Object object : list) {
             if (object instanceof Double) {
@@ -500,10 +559,10 @@ public class MemorySection implements ConfigurationSection {
             } else if (object instanceof String) {
                 try {
                     result.add(Double.valueOf((String) object));
-                } catch (Exception ex) {
+                } catch (NumberFormatException ignored) {
                 }
             } else if (object instanceof Character) {
-                result.add((double) ((Character) object).charValue());
+                result.add((double) (Character) object);
             } else if (object instanceof Number) {
                 result.add(((Number) object).doubleValue());
             }
@@ -512,14 +571,10 @@ public class MemorySection implements ConfigurationSection {
         return result;
     }
 
-    public List<Float> getFloatList(String path) {
+    @Override public List<Float> getFloatList(String path) {
         List<?> list = getList(path);
 
-        if (list == null) {
-            return new ArrayList<Float>(0);
-        }
-
-        List<Float> result = new ArrayList<Float>();
+        List<Float> result = new ArrayList<>();
 
         for (Object object : list) {
             if (object instanceof Float) {
@@ -527,10 +582,10 @@ public class MemorySection implements ConfigurationSection {
             } else if (object instanceof String) {
                 try {
                     result.add(Float.valueOf((String) object));
-                } catch (Exception ex) {
+                } catch (NumberFormatException ignored) {
                 }
             } else if (object instanceof Character) {
-                result.add((float) ((Character) object).charValue());
+                result.add((float) (Character) object);
             } else if (object instanceof Number) {
                 result.add(((Number) object).floatValue());
             }
@@ -539,14 +594,10 @@ public class MemorySection implements ConfigurationSection {
         return result;
     }
 
-    public List<Long> getLongList(String path) {
+    @Override public List<Long> getLongList(String path) {
         List<?> list = getList(path);
 
-        if (list == null) {
-            return new ArrayList<Long>(0);
-        }
-
-        List<Long> result = new ArrayList<Long>();
+        List<Long> result = new ArrayList<>();
 
         for (Object object : list) {
             if (object instanceof Long) {
@@ -554,10 +605,10 @@ public class MemorySection implements ConfigurationSection {
             } else if (object instanceof String) {
                 try {
                     result.add(Long.valueOf((String) object));
-                } catch (Exception ex) {
+                } catch (NumberFormatException ignored) {
                 }
             } else if (object instanceof Character) {
-                result.add((long) ((Character) object).charValue());
+                result.add((long) (Character) object);
             } else if (object instanceof Number) {
                 result.add(((Number) object).longValue());
             }
@@ -566,14 +617,10 @@ public class MemorySection implements ConfigurationSection {
         return result;
     }
 
-    public List<Byte> getByteList(String path) {
+    @Override public List<Byte> getByteList(String path) {
         List<?> list = getList(path);
 
-        if (list == null) {
-            return new ArrayList<Byte>(0);
-        }
-
-        List<Byte> result = new ArrayList<Byte>();
+        List<Byte> result = new ArrayList<>();
 
         for (Object object : list) {
             if (object instanceof Byte) {
@@ -581,7 +628,7 @@ public class MemorySection implements ConfigurationSection {
             } else if (object instanceof String) {
                 try {
                     result.add(Byte.valueOf((String) object));
-                } catch (Exception ex) {
+                } catch (NumberFormatException ignored) {
                 }
             } else if (object instanceof Character) {
                 result.add((byte) ((Character) object).charValue());
@@ -593,14 +640,10 @@ public class MemorySection implements ConfigurationSection {
         return result;
     }
 
-    public List<Character> getCharacterList(String path) {
+    @Override public List<Character> getCharacterList(String path) {
         List<?> list = getList(path);
 
-        if (list == null) {
-            return new ArrayList<Character>(0);
-        }
-
-        List<Character> result = new ArrayList<Character>();
+        List<Character> result = new ArrayList<>();
 
         for (Object object : list) {
             if (object instanceof Character) {
@@ -619,14 +662,10 @@ public class MemorySection implements ConfigurationSection {
         return result;
     }
 
-    public List<Short> getShortList(String path) {
+    @Override public List<Short> getShortList(String path) {
         List<?> list = getList(path);
 
-        if (list == null) {
-            return new ArrayList<Short>(0);
-        }
-
-        List<Short> result = new ArrayList<Short>();
+        List<Short> result = new ArrayList<>();
 
         for (Object object : list) {
             if (object instanceof Short) {
@@ -634,7 +673,7 @@ public class MemorySection implements ConfigurationSection {
             } else if (object instanceof String) {
                 try {
                     result.add(Short.valueOf((String) object));
-                } catch (Exception ex) {
+                } catch (NumberFormatException ignored) {
                 }
             } else if (object instanceof Character) {
                 result.add((short) ((Character) object).charValue());
@@ -646,13 +685,9 @@ public class MemorySection implements ConfigurationSection {
         return result;
     }
 
-    public List<Map<?, ?>> getMapList(String path) {
+    @Override public List<Map<?, ?>> getMapList(String path) {
         List<?> list = getList(path);
-        List<Map<?, ?>> result = new ArrayList<Map<?, ?>>();
-
-        if (list == null) {
-            return result;
-        }
+        List<Map<?, ?>> result = new ArrayList<>();
 
         for (Object object : list) {
             if (object instanceof Map) {
@@ -663,7 +698,7 @@ public class MemorySection implements ConfigurationSection {
         return result;
     }
 
-    public ConfigurationSection getConfigurationSection(String path) {
+    @Override public ConfigurationSection getConfigurationSection(String path) {
         Object val = get(path, null);
         if (val != null) {
             return (val instanceof ConfigurationSection) ? (ConfigurationSection) val : null;
@@ -673,21 +708,18 @@ public class MemorySection implements ConfigurationSection {
         return (val instanceof ConfigurationSection) ? createSection(path) : null;
     }
 
-    public boolean isConfigurationSection(String path) {
+    @Override public boolean isConfigurationSection(String path) {
         Object val = get(path);
         return val instanceof ConfigurationSection;
     }
 
     protected boolean isPrimitiveWrapper(Object input) {
-        return input instanceof Integer || input instanceof Boolean ||
-                input instanceof Character || input instanceof Byte ||
-                input instanceof Short || input instanceof Double ||
-                input instanceof Long || input instanceof Float;
+        return (input instanceof Integer) || (input instanceof Boolean)
+            || (input instanceof Character) || (input instanceof Byte) || (input instanceof Short)
+            || (input instanceof Double) || (input instanceof Long) || (input instanceof Float);
     }
 
     protected Object getDefault(String path) {
-        if (path == null) throw new NullPointerException("Path may not be null");
-
         Configuration root = getRoot();
         Configuration defaults = root == null ? null : root.getDefaults();
         return (defaults == null) ? null : defaults.get(createPath(this, path));
@@ -700,7 +732,7 @@ public class MemorySection implements ConfigurationSection {
             for (Map.Entry<String, Object> entry : sec.map.entrySet()) {
                 output.add(createPath(section, entry.getKey(), this));
 
-                if ((deep) && (entry.getValue() instanceof ConfigurationSection)) {
+                if (deep && (entry.getValue() instanceof ConfigurationSection)) {
                     ConfigurationSection subsection = (ConfigurationSection) entry.getValue();
                     mapChildrenKeys(output, subsection, deep);
                 }
@@ -714,7 +746,8 @@ public class MemorySection implements ConfigurationSection {
         }
     }
 
-    protected void mapChildrenValues(Map<String, Object> output, ConfigurationSection section, boolean deep) {
+    protected void mapChildrenValues(Map<String, Object> output, ConfigurationSection section,
+        boolean deep) {
         if (section instanceof MemorySection) {
             MemorySection sec = (MemorySection) section;
 
@@ -736,73 +769,14 @@ public class MemorySection implements ConfigurationSection {
         }
     }
 
-    /**
-     * Creates a full path to the given {@link ConfigurationSection} from its
-     * root {@link Configuration}.
-     * <p>
-     * You may use this method for any given {@link ConfigurationSection}, not
-     * only {@link MemorySection}.
-     *
-     * @param section Section to create a path for.
-     * @param key Name of the specified section.
-     * @return Full path of the section from its root.
-     */
-    public static String createPath(ConfigurationSection section, String key) {
-        return createPath(section, key, (section == null) ? null : section.getRoot());
-    }
-
-    /**
-     * Creates a relative path to the given {@link ConfigurationSection} from
-     * the given relative section.
-     * <p>
-     * You may use this method for any given {@link ConfigurationSection}, not
-     * only {@link MemorySection}.
-     *
-     * @param section Section to create a path for.
-     * @param key Name of the specified section.
-     * @param relativeTo Section to create the path relative to.
-     * @return Full path of the section from its root.
-     */
-    public static String createPath(ConfigurationSection section, String key, ConfigurationSection relativeTo) {
-        if (section == null) throw new NullPointerException("Cannot create path without a section");
-        Configuration root = section.getRoot();
-        if (root == null) {
-            throw new IllegalStateException("Cannot create path without a root");
-        }
-        char separator = root.options().pathSeparator();
-
-        StringBuilder builder = new StringBuilder();
-        if (section != null) {
-            for (ConfigurationSection parent = section; (parent != null) && (parent != relativeTo); parent = parent.getParent()) {
-                if (builder.length() > 0) {
-                    builder.insert(0, separator);
-                }
-
-                builder.insert(0, parent.getName());
-            }
-        }
-
-        if ((key != null) && (key.length() > 0)) {
-            if (builder.length() > 0) {
-                builder.append(separator);
-            }
-
-            builder.append(key);
-        }
-
-        return builder.toString();
-    }
-
-    @Override
-    public String toString() {
+    @Override public String toString() {
         Configuration root = getRoot();
-        return new StringBuilder()
-            .append(getClass().getSimpleName())
-            .append("[path='")
-            .append(getCurrentPath())
-            .append("', root='")
-            .append(root == null ? null : root.getClass().getSimpleName())
-            .append("']")
-            .toString();
+        if (root == null) {
+            return getClass().getSimpleName() + "[path='" + getCurrentPath() + "', root='" + null
+                + "']";
+        } else {
+            return getClass().getSimpleName() + "[path='" + getCurrentPath() + "', root='" + root
+                .getClass().getSimpleName() + "']";
+        }
     }
 }

Core/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/FileConfiguration.java

@@ -0,0 +1,163 @@
+package com.github.intellectualsites.plotsquared.configuration.file;
+
+import com.github.intellectualsites.plotsquared.configuration.Configuration;
+import com.github.intellectualsites.plotsquared.configuration.InvalidConfigurationException;
+import com.github.intellectualsites.plotsquared.configuration.MemoryConfiguration;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.Reader;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.util.stream.Collectors;
+
+/**
+ * This is a base class for all File based implementations of {@link
+ * Configuration}.
+ */
+public abstract class FileConfiguration extends MemoryConfiguration {
+
+    /**
+     * Creates an empty FileConfiguration with no default values.
+     */
+    FileConfiguration() {
+    }
+
+    /**
+     * Creates an empty FileConfiguration using the specified {@link
+     * Configuration} as a source for all default values.
+     *
+     * @param defaults Default value provider
+     */
+    public FileConfiguration(Configuration defaults) {
+        super(defaults);
+    }
+
+    /**
+     * Saves this FileConfiguration to the specified location.
+     *
+     * <p>If the file does not exist, it will be created. If already exists, it
+     * will be overwritten. If it cannot be overwritten or created, an
+     * exception will be thrown.
+     *
+     * <p>This method will save using the system default encoding, or possibly
+     * using UTF8.
+     *
+     * @param file File to save to.
+     * @throws IOException Thrown when the given file cannot be written to for
+     *                     any reason.
+     */
+    public void save(File file) throws IOException {
+        File parent = file.getParentFile();
+        if (parent != null) {
+            parent.mkdirs();
+        }
+
+        String data = saveToString();
+
+        try (Writer writer = new OutputStreamWriter(new FileOutputStream(file),
+            StandardCharsets.UTF_8)) {
+            writer.write(data);
+        }
+    }
+
+    /**
+     * Saves this FileConfiguration to a string, and returns it.
+     *
+     * @return String containing this configuration.
+     */
+    public abstract String saveToString();
+
+    /**
+     * Loads this FileConfiguration from the specified location.
+     *
+     * <p>All the values contained within this configuration will be removed,
+     * leaving only settings and defaults, and the new values will be loaded
+     * from the given file.
+     *
+     * <p>If the file cannot be loaded for any reason, an exception will be
+     * thrown.
+     *
+     * @param file File to load from.
+     * @throws FileNotFoundException         Thrown when the given file cannot be
+     *                                       opened.
+     * @throws IOException                   Thrown when the given file cannot be read.
+     * @throws InvalidConfigurationException Thrown when the given file is not
+     *                                       a valid Configuration.
+     * @throws IllegalArgumentException      Thrown when file is null.
+     */
+    public void load(File file) throws IOException, InvalidConfigurationException {
+
+        try (FileInputStream stream = new FileInputStream(file)) {
+            load(new InputStreamReader(stream, StandardCharsets.UTF_8));
+        }
+    }
+
+    /**
+     * Loads this FileConfiguration from the specified reader.
+     *
+     * <p>All the values contained within this configuration will be removed,
+     * leaving only settings and defaults, and the new values will be loaded
+     * from the given stream.
+     *
+     * @param reader the reader to load from
+     * @throws IOException                   thrown when underlying reader throws an IOException
+     * @throws InvalidConfigurationException thrown when the reader does not
+     *                                       represent a valid Configuration
+     */
+    public void load(Reader reader) throws IOException, InvalidConfigurationException {
+
+        String builder;
+
+        try (BufferedReader input = reader instanceof BufferedReader ?
+            (BufferedReader) reader :
+            new BufferedReader(reader)) {
+
+            builder = input.lines().map(line -> line + '\n').collect(Collectors.joining());
+        }
+
+        loadFromString(builder);
+    }
+
+    /**
+     * Loads this FileConfiguration from the specified string, as
+     * opposed to from file.
+     *
+     * <p>All the values contained within this configuration will be removed,
+     * leaving only settings and defaults, and the new values will be loaded
+     * from the given string.
+     *
+     * <p>If the string is invalid in any way, an exception will be thrown.
+     *
+     * @param contents Contents of a Configuration to load.
+     * @throws InvalidConfigurationException Thrown if the specified string is
+     *                                       invalid.
+     */
+    public abstract void loadFromString(String contents) throws InvalidConfigurationException;
+
+    /**
+     * Compiles the header for this FileConfiguration and returns the
+     * result.
+     *
+     * <p>This will use the header from {@link #options()} -> {@link
+     * FileConfigurationOptions#header()}, respecting the rules of {@link
+     * FileConfigurationOptions#copyHeader()} if set.
+     *
+     * @return Compiled header
+     */
+    protected abstract String buildHeader();
+
+    @Override public FileConfigurationOptions options() {
+        if (this.options == null) {
+            this.options = new FileConfigurationOptions(this);
+        }
+
+        return (FileConfigurationOptions) this.options;
+    }
+}