Merge pull request #2564 from IntellectualSites/we

Use patterns instead of BlockBucket

.github/CONTRIBUTING.md

@@ -1,2 +0,0 @@
-### Bugs
-Please provide a `/plot debugpaste` if you are reporting a bug.

.github/ISSUE_TEMPLATE.md

@@ -1,12 +1,28 @@
-# Bug report template (clear for feature request)
-**Debug paste link**:
+__*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 -->
 
-**Description of the problem:**
+**[REQUIRED] Spigot/Paper Version Number:** 
 
-**How to replicate**:
+**[REQUIRED] Minecraft Version Number:** 
 
-Make sure you've completed the following steps (put X inside of brackets):
-- [ ] Include `/plot debugpaste`
-- [ ] Made sure there aren't duplicates of this report [(Use Search)](https://github.com/IntellectualSites/PlotSquared/issues)
-- [ ] Made sure you're using an updated version of PlotSquared
-- [ ] Made sure the bug/error isn't caused by any other plugin
+**[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,90 @@
+---
+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 recieve 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 (Debug/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): -->
+- [ ] Minecraft 1.14.4 ***This is the ONLY actively maintained target for PlotSquared***
+- [ ] Minecraft 1.13.2
+- [ ] Minecraft Java Edition *other versions, please specify*:
+- [ ] Minecraft Bedrock Edition *speicify version*:
+
+### Server build info: 
+<!--- Run /version in-game or in console & paste the full output here: -->
+``` paste 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/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,24 @@
+name: Java CI
+
+on:
+  push:
+    branches:
+    - breaking
+    - master
+  pull_request:
+    branches:
+    - breaking
+    - master
+ 
+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,13 +1,14 @@
 ### Others ###
-*.bat
 *.cmd
 *.sh
 *.prefs
 Sponge/build
 Core/build
 Bukkit/build
+Nukkit/build
 
 ### Maven ###
+/mvn
 /target/lib
 /target/maven-archiver
 /target/classes
@@ -20,6 +21,7 @@ release.properties
 dependency-reduced-pom.xml
 buildNumber.properties
 .mvn/timing.properties
+out/
 
 
 ### Java ###
@@ -29,7 +31,6 @@ buildNumber.properties
 .mtj.tmp/
 
 # Package Files #
-*.jar
 *.war
 *.ear
 
@@ -131,4 +132,12 @@ local.properties
 
 # STS (Spring Tool Suite)
 .springBeans
-/target/
+/target/
+Nukkit/build/classes/
+Nukkit/build/dependency-cache/
+checkstyle.xml
+classes/
+p2error.txt
+*.bat
+Nukkit/build/resources/main/plugin.yml
+docs/

Bukkit/build.gradle

@@ -1,35 +1,105 @@
-dependencies {
-    compile project(':Core')
-    compile 'org.bukkit:bukkit:1.9-R0.1-SNAPSHOT'
-    compile 'net.milkbowl.vault:VaultAPI:1.5'
+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()
 }
 
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+
+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.14.4-R0.1-SNAPSHOT")
+    compile(group: "com.sk89q.worldedit", name: "worldedit-bukkit", version: "7.0.0")
+    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'
+    from("src/main/resources") {
+        include("plugin.yml")
         expand(
-            name: project.parent.name,
-            version: project.parent.version
+                name: project.parent.name,
+                version: project.parent.version
         )
     }
 }
 
-apply plugin: 'com.github.johnrengelman.shadow'
-// We only want the shadow jar produced
-jar.enabled = false
-shadowJar {
-    dependencies {
-        include(dependency(':Core'))
+//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")
     }
-    archiveName = "${parent.name}-${project.name}-${parent.version}.jar"
-    destinationDir = file '../target'
-}
-shadowJar.doLast {
-    task ->
-    ant.checksum file: task.archivePath
 }
 
-build.dependsOn(shadowJar);
+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:3.12.0"))
+        include(dependency("com.squareup.okio:okio:2.2.2"))
+        include(dependency("org.jetbrains.kotlin:kotlin-stdlib:1.3.50"))
+        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")
+    // relocate('org.mcstats', 'com.plotsquared.stats')
+    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,835 @@
+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.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+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;
+
+    @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 update. 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:
+                        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();
+    }
+
+    @Override public void startMetrics() {
+        if (this.metricsStarted) {
+            return;
+        }
+        this.metricsStarted = true;
+        Metrics metrics = new Metrics(this);// 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<String> getPluginIds() {
+        final List<String> names = new ArrayList<>();
+        for (final Plugin plugin : Bukkit.getPluginManager().getPlugins()) {
+            names.add(plugin.getName() + ';' + plugin.getDescription().getVersion() + ':' + 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

@@ -1,103 +1,107 @@
-package com.plotsquared.bukkit.chat;
+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;
 
-import org.apache.commons.lang.Validate;
-
 /**
  * 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>
- * @author Glen Husman
+ *
  * @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(final E... elements) {
+    public ArrayWrapper(E... elements) {
         setArray(elements);
     }
-    
-    private E[] _array;
-    
+
+    /**
+     * 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(final E[] 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(final Object other) {
+    @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.
-     * @see Arrays#hashCode(Object[])
+     *
      * @return This object's hash code.
+     * @see Arrays#hashCode(Object[])
      */
-    @Override
-    public int hashCode() {
+    @Override public int hashCode() {
         return Arrays.hashCode(_array);
     }
-    
-    /**
-     * 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(final Iterable<? extends T> list, final Class<T> c) {
-        int size = -1;
-        if (list instanceof Collection<?>) {
-            @SuppressWarnings("rawtypes")
-            final Collection coll = (Collection) list;
-            size = coll.size();
-        }
-        
-        if (size < 0) {
-            size = 0;
-            // Ugly hack: Count it ourselves
-            for (@SuppressWarnings("unused")
-            final T element : list) {
-                size++;
-            }
-        }
-        
-        final T[] result = (T[]) Array.newInstance(c, size);
-        int i = 0;
-        for (final T element : list) { // Assumes iteration order is consistent
-            result[i++] = element; // Assign array element at index THEN increment counter
-        }
-        return result;
-    }
+
 }

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

@@ -1,19 +1,20 @@
-package com.plotsquared.bukkit.chat;
-
-import java.io.IOException;
+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.
      */
-    void writeJson(final JsonWriter writer) throws IOException;
-    
+    public void writeJson(JsonWriter writer) throws IOException;
+
 }

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

@@ -1,47 +1,45 @@
-package com.plotsquared.bukkit.chat;
+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;
 
-import com.google.gson.stream.JsonWriter;
-import com.intellectualcrafters.configuration.serialization.ConfigurationSerializable;
-
 /**
  * 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 final String _value;
-    
-    public JsonString(final CharSequence value) {
+
+    private String _value;
+
+    public JsonString(CharSequence value) {
         _value = value == null ? null : value.toString();
     }
-    
-    @Override
-    public void writeJson(final JsonWriter writer) throws IOException {
+
+    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;
     }
-    
-    @Override
+
     public Map<String, Object> serialize() {
-        final HashMap<String, Object> theSingleValue = new HashMap<String, Object>();
+        HashMap<String, Object> theSingleValue = new HashMap<String, Object>();
         theSingleValue.put("stringValue", _value);
         return theSingleValue;
     }
-    
-    public static JsonString deserialize(final Map<String, Object> map) {
-        return new JsonString(map.get("stringValue").toString());
-    }
-    
-    @Override
-    public String toString() {
+
+    @Override public String toString() {
         return _value;
     }
+
 }

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

@@ -1,12 +1,12 @@
-package com.plotsquared.bukkit.chat;
+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 com.intellectualcrafters.configuration.serialization.ConfigurationSerializable;
-import com.intellectualcrafters.configuration.serialization.ConfigurationSerialization;
 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;
@@ -22,7 +22,7 @@ final class MessagePart implements JsonRepresentedObject, ConfigurationSerializa
     static final BiMap<ChatColor, String> stylesToNames;
 
     static {
-        final ImmutableBiMap.Builder<ChatColor, String> builder = ImmutableBiMap.builder();
+        ImmutableBiMap.Builder<ChatColor, String> builder = ImmutableBiMap.builder();
         for (final ChatColor style : ChatColor.values()) {
             if (!style.isFormat()) {
                 continue;
@@ -51,24 +51,26 @@ final class MessagePart implements JsonRepresentedObject, ConfigurationSerializa
     }
 
     ChatColor color = ChatColor.WHITE;
-    ArrayList<ChatColor> styles = new ArrayList<ChatColor>();
-    String clickActionName = null, clickActionData = null, hoverActionName = null;
+    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<JsonRepresentedObject>();
-    
+    ArrayList<JsonRepresentedObject> translationReplacements = new ArrayList<>();
+
     MessagePart(final TextualComponent text) {
         this.text = text;
     }
-    
+
     MessagePart() {
-        text = null;
+        this.text = null;
     }
 
     @SuppressWarnings("unchecked")
-    public static MessagePart deserialize(final Map<String, Object> serialized) {
-        final MessagePart part = new MessagePart((TextualComponent) serialized.get("text"));
+    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");
@@ -76,31 +78,31 @@ final class MessagePart implements JsonRepresentedObject, ConfigurationSerializa
         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");
+        part.translationReplacements =
+            (ArrayList<JsonRepresentedObject>) serialized.get("translationReplacements");
         return part;
     }
 
     boolean hasText() {
         return text != null;
     }
-    
-    @Override
-    @SuppressWarnings("unchecked")
-    public MessagePart clone() throws CloneNotSupportedException {
-        final MessagePart obj = (MessagePart) super.clone();
+
+    @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();
+        obj.translationReplacements =
+            (ArrayList<JsonRepresentedObject>) translationReplacements.clone();
         return obj;
 
     }
-    
-    @Override
-    public void writeJson(final JsonWriter json) {
+
+    public void writeJson(JsonWriter json) {
         try {
             json.beginObject();
             text.writeJson(json);
@@ -108,33 +110,35 @@ final class MessagePart implements JsonRepresentedObject, ConfigurationSerializa
             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 (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");
+            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.isEmpty()) && (text != null) && TextualComponent.isTranslatableText(text)) {
+            if (translationReplacements.size() > 0 && TextualComponent.isTranslatableText(text)) {
                 json.name("with").beginArray();
-                for (final JsonRepresentedObject obj : translationReplacements) {
+                for (JsonRepresentedObject obj : translationReplacements) {
                     obj.writeJson(json);
                 }
                 json.endArray();
             }
             json.endObject();
-        } catch (final IOException e) {
-            Bukkit.getLogger().log(Level.WARNING, "A problem occurred during writing of JSON string", e);
+        } catch (IOException e) {
+            Bukkit.getLogger()
+                .log(Level.WARNING, "A problem occurred during writing of JSON string", e);
         }
     }
-    
-    @Override
+
     public Map<String, Object> serialize() {
-        final HashMap<String, Object> map = new HashMap<String, Object>();
+        HashMap<String, Object> map = new HashMap<>();
         map.put("text", text);
         map.put("styles", styles);
         map.put("color", color.getChar());
@@ -146,5 +150,5 @@ final class MessagePart implements JsonRepresentedObject, ConfigurationSerializa
         map.put("translationReplacements", translationReplacements);
         return map;
     }
-    
+
 }

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

@@ -1,4 +1,4 @@
-package com.plotsquared.bukkit.chat;
+package com.github.intellectualsites.plotsquared.bukkit.chat;
 
 import org.bukkit.Bukkit;
 
@@ -28,105 +28,90 @@ public final class Reflection {
      * 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 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) {
-            if (Bukkit.getServer() == null) {
-                // The server hasn't started, static initializer call?
-                return null;
-            }
-            final String name = Bukkit.getServer().getClass().getPackage().getName();
+            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(final String className) {
+    public synchronized static Class<?> getNMSClass(String className) {
         if (_loadedNMSClasses.containsKey(className)) {
             return _loadedNMSClasses.get(className);
         }
 
-        final String fullName = "net.minecraft.server." + getVersion() + className;
+        String fullName = "net.minecraft.server." + getVersion() + className;
         Class<?> clazz;
         try {
             clazz = Class.forName(fullName);
         } catch (ClassNotFoundException e) {
-            e.printStackTrace();
             _loadedNMSClasses.put(className, null);
-            return 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}.
+     * 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(final String className) {
+    public synchronized static Class<?> getOBCClass(String className) {
         if (_loadedOBCClasses.containsKey(className)) {
             return _loadedOBCClasses.get(className);
         }
 
-        final String fullName = "org.bukkit.craftbukkit." + getVersion() + className;
+        String fullName = "org.bukkit.craftbukkit." + getVersion() + className;
         Class<?> clazz;
         try {
             clazz = Class.forName(fullName);
         } catch (ClassNotFoundException e) {
-            e.printStackTrace();
             _loadedOBCClasses.put(className, null);
-            return 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.
+     * 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(final Object obj) {
-        try {
-            return getMethod(obj.getClass(), "getHandle").invoke(obj);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-            return null;
-        } catch (IllegalArgumentException e) {
-            e.printStackTrace();
-            return null;
-        } catch (InvocationTargetException e) {
-            e.printStackTrace();
-            return null;
-        }
+    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
@@ -136,16 +121,16 @@ public final class Reflection {
      * 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.
+     * 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.
+     * @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(final Class<?> clazz, final String name) {
+    public synchronized static Field getField(Class<?> clazz, String name) {
         Map<String, Field> loaded;
         if (!_loadedFields.containsKey(clazz)) {
             loaded = new HashMap<>();
@@ -158,17 +143,11 @@ public final class Reflection {
             return loaded.get(name);
         }
         try {
-            final Field field = clazz.getDeclaredField(name);
+            Field field = clazz.getDeclaredField(name);
             field.setAccessible(true);
             loaded.put(name, field);
             return field;
-        } catch (NoSuchFieldException e) {
-            // Error loading
-            e.printStackTrace();
-            // Cache field as not existing
-            loaded.put(name, null);
-            return null;
-        } catch (SecurityException e) {
+        } catch (NoSuchFieldException | SecurityException e) {
             // Error loading
             e.printStackTrace();
             // Cache field as not existing
@@ -176,7 +155,7 @@ public final class Reflection {
             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
@@ -184,36 +163,32 @@ public final class Reflection {
      * <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>
      * <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>
      * <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.
+     * @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(final Class<?> clazz, final String name, final Class<?>... args) {
-        if (!_loadedMethods.containsKey(clazz)) {
-            _loadedMethods.put(clazz, new HashMap<String, Map<ArrayWrapper<Class<?>>, Method>>());
-        }
-        
-        final Map<String, Map<ArrayWrapper<Class<?>>, Method>> loadedMethodNames = _loadedMethods.get(clazz);
-        if (!loadedMethodNames.containsKey(name)) {
-            loadedMethodNames.put(name, new HashMap<ArrayWrapper<Class<?>>, Method>());
-        }
-        
-        final Map<ArrayWrapper<Class<?>>, Method> loadedSignatures = loadedMethodNames.get(name);
-        final ArrayWrapper<Class<?>> wrappedArg = new ArrayWrapper<>(args);
+    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 (final Method m : clazz.getMethods()) {
+
+        for (Method m : clazz.getMethods()) {
             if (m.getName().equals(name) && Arrays.equals(args, m.getParameterTypes())) {
                 m.setAccessible(true);
                 loadedSignatures.put(wrappedArg, m);
@@ -223,5 +198,5 @@ public final class Reflection {
         loadedSignatures.put(wrappedArg, null);
         return null;
     }
-    
+
 }

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

@@ -1,10 +1,10 @@
-package com.plotsquared.bukkit.chat;
+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 com.intellectualcrafters.configuration.serialization.ConfigurationSerializable;
-import com.intellectualcrafters.configuration.serialization.ConfigurationSerialization;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
 
 import java.io.IOException;
 import java.util.HashMap;
@@ -23,8 +23,123 @@ public abstract class TextualComponent implements Cloneable {
         ConfigurationSerialization.registerClass(TextualComponent.ComplexTextTypeComponent.class);
     }
 
-    @Override
-    public String toString() {
+    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();
     }
 
@@ -42,84 +157,66 @@ public abstract class TextualComponent implements Cloneable {
      * 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;
+    @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(final JsonWriter writer) throws IOException;
-
-    static TextualComponent deserialize(final 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(final String key) {
-        return key.equals("translate") || key.equals("text") || key.equals("score") || key.equals("selector");
-    }
-
-    static boolean isTranslatableText(final TextualComponent component) {
-        return (component instanceof ComplexTextTypeComponent) && ((ComplexTextTypeComponent) component).getKey().equals("translate");
-    }
+    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 static final class ArbitraryTextTypeComponent extends TextualComponent
+        implements ConfigurationSerializable {
 
-        public ArbitraryTextTypeComponent(final String key, final String value) {
+        private String key;
+        private String value;
+
+        public ArbitraryTextTypeComponent(String key, String value) {
             setKey(key);
             setValue(value);
         }
 
-        @Override
-        public String getKey() {
-            return _key;
+        public static ArbitraryTextTypeComponent deserialize(Map<String, Object> map) {
+            return new ArbitraryTextTypeComponent(map.get("key").toString(),
+                map.get("value").toString());
         }
 
-        public void setKey(final String key) {
-            Preconditions.checkArgument((key != null) && !key.isEmpty(), "The key must be specified.");
-            _key = key;
+        @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;
+            return value;
         }
 
-        public void setValue(final String value) {
+        public void setValue(String value) {
             Preconditions.checkArgument(value != null, "The value must be specified.");
-            _value = value;
+            this.value = value;
         }
 
-        private String _key;
-        private String _value;
-
-        @Override
-        public TextualComponent clone() throws CloneNotSupportedException {
+        @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(final JsonWriter writer) throws IOException {
+        @Override public void writeJson(JsonWriter writer) throws IOException {
             writer.name(getKey()).value(getValue());
         }
 
-        @Override
-        @SuppressWarnings("serial")
-        public Map<String, Object> serialize() {
+        @Override @SuppressWarnings("serial") public Map<String, Object> serialize() {
             return new HashMap<String, Object>() {
                 {
                     put("key", getKey());
@@ -128,166 +225,89 @@ public abstract class TextualComponent implements Cloneable {
             };
         }
 
-        public static ArbitraryTextTypeComponent deserialize(final Map<String, Object> map) {
-            return new ArbitraryTextTypeComponent(map.get("key").toString(), map.get("value").toString());
-        }
-
-        @Override
-        public String getReadableString() {
+        @Override public String getReadableString() {
             return getValue();
         }
     }
 
-    /**
-     * Internal class used to represent a text component with a nested JSON value.
-     * Exception validating done is on keys and values.
-     */
-    private static final class ComplexTextTypeComponent extends TextualComponent implements ConfigurationSerializable {
 
-        public ComplexTextTypeComponent(final String key, final Map<String, String> values) {
+    /**
+     * 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);
         }
 
-        @Override
-        public String getKey() {
-            return _key;
+        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);
         }
 
-        public void setKey(final String key) {
-            Preconditions.checkArgument((key != null) && !key.isEmpty(), "The key must be specified.");
-            _key = key;
+        @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;
+            return value;
         }
 
-        public void setValue(final Map<String, String> value) {
+        public void setValue(Map<String, String> value) {
             Preconditions.checkArgument(value != null, "The value must be specified.");
-            _value = value;
+            this.value = value;
         }
 
-        private String _key;
-        private Map<String, String> _value;
-
-        @Override
-        public TextualComponent clone() throws CloneNotSupportedException {
+        @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(final JsonWriter writer) throws IOException {
+        @Override public void writeJson(JsonWriter writer) throws IOException {
             writer.name(getKey());
             writer.beginObject();
-            for (final Map.Entry<String, String> jsonPair : _value.entrySet()) {
+            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() {
+        @Override @SuppressWarnings("serial") public Map<String, Object> serialize() {
             return new java.util.HashMap<String, Object>() {
                 {
                     put("key", getKey());
-                    for (final Map.Entry<String, String> valEntry : getValue().entrySet()) {
+                    for (Map.Entry<String, String> valEntry : getValue().entrySet()) {
                         put("value." + valEntry.getKey(), valEntry.getValue());
                     }
                 }
             };
         }
 
-        public static ComplexTextTypeComponent deserialize(final Map<String, Object> map) {
-            String key = null;
-            final Map<String, String> value = new HashMap<String, String>();
-            for (final 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 getReadableString() {
+        @Override public String getReadableString() {
             return getKey();
         }
     }
-
-    /**
-     * Create a textual component representing a string literal.
-     * 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(final 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(final 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(final 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>
-     * </p>
-     * @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(final String playerName, final 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(final 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);
-    }
 }

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

@@ -0,0 +1,18 @@
+package com.github.intellectualsites.plotsquared.bukkit.events;
+
+import com.github.intellectualsites.plotsquared.plot.object.Plot;
+import org.bukkit.event.Event;
+
+public abstract class PlotEvent extends Event {
+
+    private final Plot plot;
+
+    public PlotEvent(Plot plot) {
+        this.plot = plot;
+    }
+
+    public final Plot getPlot() {
+        return this.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

@@ -1,17 +1,16 @@
-package com.plotsquared.bukkit.generator;
+package com.github.intellectualsites.plotsquared.bukkit.generator;
 
-import com.intellectualcrafters.plot.generator.AugmentedUtils;
+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;
-    
-    private BukkitAugmentedGenerator() {}
 
     public static BukkitAugmentedGenerator get(World world) {
         for (BlockPopulator populator : world.getPopulators()) {
@@ -27,7 +26,7 @@ public class BukkitAugmentedGenerator extends BlockPopulator {
     }
 
     @Override
-    public void populate(final World world, Random r, final Chunk chunk) {
-        AugmentedUtils.generate(world.getName(), chunk.getX(), chunk.getZ(), null);
+    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,208 @@
+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,26 @@
+package com.github.intellectualsites.plotsquared.bukkit.object;
+
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.world.block.BlockState;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+
+import java.util.function.Supplier;
+
+public class BukkitBlockUtil {
+    public static Supplier<BlockState> supply(Block block) {
+        return () -> BukkitAdapter.asBlockType(block.getType()).getDefaultState();
+    }
+
+    public static Supplier<BlockState> supply(Material type) {
+        return () -> BukkitAdapter.asBlockType(type).getDefaultState();
+    }
+
+    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

@@ -0,0 +1,38 @@
+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;
+
+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.
+     *
+     * @param player
+     */
+    public BukkitOfflinePlayer(OfflinePlayer player) {
+        this.player = player;
+    }
+
+    @NotNull @Override public UUID getUUID() {
+        return this.player.getUniqueId();
+    }
+
+    @Override public long getLastPlayed() {
+        return this.player.getLastPlayed();
+    }
+
+    @Override public boolean isOnline() {
+        return this.player.isOnline();
+    }
+
+    @Override public String getName() {
+        return this.player.getName();
+    }
+}

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

@@ -0,0 +1,313 @@
+package com.github.intellectualsites.plotsquared.bukkit.object;
+
+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.util.EconHandler;
+import com.github.intellectualsites.plotsquared.plot.util.MathMan;
+import com.github.intellectualsites.plotsquared.plot.util.PlotGameMode;
+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 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;
+
+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) {
+        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, PlayerTeleportEvent.TeleportCause.PLUGIN);
+    }
+
+    @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 PlotGameMode getGameMode() {
+        switch (this.player.getGameMode()) {
+            case ADVENTURE:
+                return PlotGameMode.ADVENTURE;
+            case CREATIVE:
+                return PlotGameMode.CREATIVE;
+            case SPECTATOR:
+                return PlotGameMode.SPECTATOR;
+            case SURVIVAL:
+                return PlotGameMode.SURVIVAL;
+            default:
+                return PlotGameMode.NOT_SET;
+        }
+    }
+
+    @Override public void setGameMode(@NotNull final PlotGameMode gameMode) {
+        switch (gameMode) {
+            case ADVENTURE:
+                this.player.setGameMode(GameMode.ADVENTURE);
+                break;
+            case CREATIVE:
+                this.player.setGameMode(GameMode.CREATIVE);
+                break;
+            case SPECTATOR:
+                this.player.setGameMode(GameMode.SPECTATOR);
+                break;
+            case SURVIVAL:
+            default:
+                this.player.setGameMode(GameMode.SURVIVAL);
+                break;
+        }
+    }
+
+    @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.getBlockType().getMaterial().isAir()) {
+            // 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() == PlotGameMode.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/ReplicatingEntityWrapper.java

@@ -0,0 +1,727 @@
+package com.github.intellectualsites.plotsquared.bukkit.object.entity;
+
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import org.bukkit.Art;
+import org.bukkit.DyeColor;
+import org.bukkit.Location;
+import org.bukkit.Rotation;
+import org.bukkit.TreeSpecies;
+import org.bukkit.World;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.AbstractHorse;
+import org.bukkit.entity.Ageable;
+import org.bukkit.entity.ArmorStand;
+import org.bukkit.entity.Bat;
+import org.bukkit.entity.Boat;
+import org.bukkit.entity.ChestedHorse;
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.IronGolem;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.ItemFrame;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Painting;
+import org.bukkit.entity.Rabbit;
+import org.bukkit.entity.Sheep;
+import org.bukkit.entity.Slime;
+import org.bukkit.entity.Tameable;
+import org.bukkit.inventory.EntityEquipment;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.util.EulerAngle;
+import org.bukkit.util.Vector;
+
+import java.util.List;
+
+public final class ReplicatingEntityWrapper extends EntityWrapper {
+
+    private final short depth;
+    private final int hash;
+    private final EntityBaseStats base = new EntityBaseStats();
+
+    private ItemStack[] inventory;
+    // Extended
+    private ItemStack stack;
+    private byte dataByte;
+    private byte dataByte2;
+    private String dataString;
+    private LivingEntityStats lived;
+    private AgeableStats aged;
+    private TameableStats tamed;
+    private ArmorStandStats stand;
+    private HorseStats horse;
+    private boolean noGravity;
+
+    public ReplicatingEntityWrapper(Entity entity, short depth) {
+        super(entity);
+
+        this.hash = entity.getEntityId();
+        this.depth = depth;
+
+        if (depth == 0) {
+            return;
+        }
+        List<Entity> passengers = entity.getPassengers();
+        if (passengers.size() > 0) {
+            this.base.passenger = new ReplicatingEntityWrapper(passengers.get(0), depth);
+        }
+        this.base.fall = entity.getFallDistance();
+        this.base.fire = (short) entity.getFireTicks();
+        this.base.age = entity.getTicksLived();
+        Vector velocity = entity.getVelocity();
+        this.base.vX = velocity.getX();
+        this.base.vY = velocity.getY();
+        this.base.vZ = velocity.getZ();
+        if (depth == 1) {
+            return;
+        }
+        if (!entity.hasGravity()) {
+            this.noGravity = true;
+        }
+        switch (entity.getType()) {
+            case BOAT:
+                Boat boat = (Boat) entity;
+                this.dataByte = getOrdinal(TreeSpecies.values(), boat.getWoodType());
+                return;
+            case ARROW:
+            case EGG:
+            case ENDER_CRYSTAL:
+            case ENDER_PEARL:
+            case ENDER_SIGNAL:
+            case EXPERIENCE_ORB:
+            case FALLING_BLOCK:
+            case FIREBALL:
+            case FIREWORK:
+            case FISHING_HOOK:
+            case LEASH_HITCH:
+            case LIGHTNING:
+            case MINECART:
+            case MINECART_COMMAND:
+            case MINECART_MOB_SPAWNER:
+            case MINECART_TNT:
+            case PLAYER:
+            case PRIMED_TNT:
+            case SLIME:
+            case SMALL_FIREBALL:
+            case SNOWBALL:
+            case MINECART_FURNACE:
+            case SPLASH_POTION:
+            case THROWN_EXP_BOTTLE:
+            case WITHER_SKULL:
+            case UNKNOWN:
+            case SPECTRAL_ARROW:
+            case SHULKER_BULLET:
+            case DRAGON_FIREBALL:
+            case AREA_EFFECT_CLOUD:
+            case TRIDENT:
+            case LLAMA_SPIT:
+                // Do this stuff later
+                return;
+            // MISC //
+            case DROPPED_ITEM:
+                Item item = (Item) entity;
+                this.stack = item.getItemStack();
+                return;
+            case ITEM_FRAME:
+                this.x = Math.floor(this.x);
+                this.y = Math.floor(this.y);
+                this.z = Math.floor(this.z);
+                ItemFrame itemFrame = (ItemFrame) entity;
+                this.dataByte = getOrdinal(Rotation.values(), itemFrame.getRotation());
+                this.stack = itemFrame.getItem().clone();
+                return;
+            case PAINTING:
+                this.x = Math.floor(this.x);
+                this.y = Math.floor(this.y);
+                this.z = Math.floor(this.z);
+                Painting painting = (Painting) entity;
+                Art art = painting.getArt();
+                this.dataByte = getOrdinal(BlockFace.values(), painting.getFacing());
+                int h = art.getBlockHeight();
+                if (h % 2 == 0) {
+                    this.y -= 1;
+                }
+                this.dataString = art.name();
+                return;
+            // END MISC //
+            // INVENTORY HOLDER //
+            case MINECART_CHEST:
+            case MINECART_HOPPER:
+                storeInventory((InventoryHolder) entity);
+                return;
+            // START LIVING ENTITY //
+            // START AGEABLE //
+            // START TAMEABLE //
+            case HORSE:
+            case DONKEY:
+            case LLAMA:
+            case MULE:
+            case SKELETON_HORSE:
+                AbstractHorse horse = (AbstractHorse) entity;
+                this.horse = new HorseStats();
+                this.horse.jump = horse.getJumpStrength();
+                if (horse instanceof ChestedHorse) {
+                    ChestedHorse horse1 = (ChestedHorse) horse;
+                    this.horse.chest = horse1.isCarryingChest();
+                }
+                //todo these horse features need fixing
+                //this.horse.variant = horse.getVariant();
+                //this.horse.style = horse.getStyle();
+                //this.horse.color = horse.getColor();
+                storeTameable(horse);
+                storeAgeable(horse);
+                storeLiving(horse);
+                storeInventory(horse);
+                return;
+            // END INVENTORY HOLDER //
+            case WOLF:
+            case OCELOT:
+                storeTameable((Tameable) entity);
+                storeAgeable((Ageable) entity);
+                storeLiving((LivingEntity) entity);
+                return;
+            // END TAMEABLE //
+            //todo fix sheep
+            case SHEEP:
+                Sheep sheep = (Sheep) entity;
+                if (sheep.isSheared()) {
+                    this.dataByte = (byte) 1;
+                } else {
+                    this.dataByte = (byte) 0;
+                }
+                this.dataByte2 = sheep.getColor().getDyeData();
+                storeAgeable(sheep);
+                storeLiving(sheep);
+                return;
+            case VILLAGER:
+            case CHICKEN:
+            case COW:
+            case MUSHROOM_COW:
+            case PIG:
+            case TURTLE:
+            case POLAR_BEAR:
+                storeAgeable((Ageable) entity);
+                storeLiving((LivingEntity) entity);
+                return;
+            case RABBIT:
+                this.dataByte = getOrdinal(Rabbit.Type.values(), ((Rabbit) entity).getRabbitType());
+                storeAgeable((Ageable) entity);
+                storeLiving((LivingEntity) entity);
+                return;
+            // END AGEABLE //
+            case ARMOR_STAND:
+                ArmorStand stand = (ArmorStand) entity;
+                this.inventory =
+                    new ItemStack[] {stand.getItemInHand().clone(), stand.getHelmet().clone(),
+                        stand.getChestplate().clone(), stand.getLeggings().clone(),
+                        stand.getBoots().clone()};
+                storeLiving(stand);
+                this.stand = new ArmorStandStats();
+
+                EulerAngle head = stand.getHeadPose();
+                this.stand.head[0] = (float) head.getX();
+                this.stand.head[1] = (float) head.getY();
+                this.stand.head[2] = (float) head.getZ();
+
+                EulerAngle body = stand.getBodyPose();
+                this.stand.body[0] = (float) body.getX();
+                this.stand.body[1] = (float) body.getY();
+                this.stand.body[2] = (float) body.getZ();
+
+                EulerAngle leftLeg = stand.getLeftLegPose();
+                this.stand.leftLeg[0] = (float) leftLeg.getX();
+                this.stand.leftLeg[1] = (float) leftLeg.getY();
+                this.stand.leftLeg[2] = (float) leftLeg.getZ();
+
+                EulerAngle rightLeg = stand.getRightLegPose();
+                this.stand.rightLeg[0] = (float) rightLeg.getX();
+                this.stand.rightLeg[1] = (float) rightLeg.getY();
+                this.stand.rightLeg[2] = (float) rightLeg.getZ();
+
+                EulerAngle leftArm = stand.getLeftArmPose();
+                this.stand.leftArm[0] = (float) leftArm.getX();
+                this.stand.leftArm[1] = (float) leftArm.getY();
+                this.stand.leftArm[2] = (float) leftArm.getZ();
+
+                EulerAngle rightArm = stand.getRightArmPose();
+                this.stand.rightArm[0] = (float) rightArm.getX();
+                this.stand.rightArm[1] = (float) rightArm.getY();
+                this.stand.rightArm[2] = (float) rightArm.getZ();
+
+                if (stand.hasArms()) {
+                    this.stand.arms = true;
+                }
+                if (!stand.hasBasePlate()) {
+                    this.stand.noPlate = true;
+                }
+                if (!stand.isVisible()) {
+                    this.stand.invisible = true;
+                }
+                if (stand.isSmall()) {
+                    this.stand.small = true;
+                }
+                return;
+            case ENDERMITE:
+                return;
+            case BAT:
+                if (((Bat) entity).isAwake()) {
+                    this.dataByte = (byte) 1;
+                } else {
+                    this.dataByte = (byte) 0;
+                }
+                return;
+            case ENDER_DRAGON:
+                EnderDragon entity1 = (EnderDragon) entity;
+                this.dataByte = (byte) entity1.getPhase().ordinal();
+                return;
+            case SKELETON:
+            case WITHER_SKELETON:
+            case GUARDIAN:
+            case ELDER_GUARDIAN:
+            case GHAST:
+            case MAGMA_CUBE:
+            case SQUID:
+            case PIG_ZOMBIE:
+            case ZOMBIE:
+            case WITHER:
+            case WITCH:
+            case SPIDER:
+            case CAVE_SPIDER:
+            case SILVERFISH:
+            case GIANT:
+            case ENDERMAN:
+            case CREEPER:
+            case BLAZE:
+            case SHULKER:
+            case SNOWMAN:
+                storeLiving((LivingEntity) entity);
+                return;
+            case IRON_GOLEM:
+                if (((IronGolem) entity).isPlayerCreated()) {
+                    this.dataByte = (byte) 1;
+                } else {
+                    this.dataByte = (byte) 0;
+                }
+                storeLiving((LivingEntity) entity);
+                return;
+                // END LIVING //
+            default:
+                PlotSquared.debug("&cCOULD NOT IDENTIFY ENTITY: " + entity.getType());
+        }
+    }
+
+    @Override public boolean equals(Object obj) {
+        return this.hash == obj.hashCode();
+    }
+
+    @Override public int hashCode() {
+        return this.hash;
+    }
+
+    public void storeInventory(InventoryHolder held) {
+        this.inventory = held.getInventory().getContents().clone();
+    }
+
+    void restoreLiving(LivingEntity entity) {
+        entity.setCanPickupItems(this.lived.loot);
+        if (this.lived.name != null) {
+            entity.setCustomName(this.lived.name);
+            entity.setCustomNameVisible(this.lived.visible);
+        }
+        if (this.lived.potions != null && !this.lived.potions.isEmpty()) {
+            entity.addPotionEffects(this.lived.potions);
+        }
+        entity.setRemainingAir(this.lived.air);
+        entity.setRemoveWhenFarAway(this.lived.persistent);
+        if (this.lived.equipped) {
+            this.restoreEquipment(entity);
+        }
+        if (this.lived.leashed) {
+            // TODO leashes
+            //            World world = entity.getWorld();
+            //            Entity leash = world.spawnEntity(new Location(world, Math.floor(x) +
+            //            lived.leashX, Math.floor(y) + lived.leashY, Math.floor(z) + lived.leashZ),
+            //            EntityType.LEASH_HITCH);
+            //            entity.setLeashHolder(leash);
+        }
+    }
+
+    void restoreEquipment(LivingEntity entity) {
+        EntityEquipment equipment = entity.getEquipment();
+        if (equipment != null) {
+            equipment.setItemInMainHand(this.lived.mainHand);
+            equipment.setItemInOffHand(this.lived.offHand);
+            equipment.setHelmet(this.lived.helmet);
+            equipment.setChestplate(this.lived.chestplate);
+            equipment.setLeggings(this.lived.leggings);
+            equipment.setBoots(this.lived.boots);
+        }
+    }
+
+    private void restoreInventory(InventoryHolder entity) {
+        try {
+            entity.getInventory().setContents(this.inventory);
+        } catch (IllegalArgumentException e) {
+            PlotSquared.debug("&c[WARN] Failed to restore inventory.\n Reason: " + e.getMessage());
+        }
+    }
+
+    private void storeLiving(LivingEntity lived) {
+        this.lived = new LivingEntityStats();
+        this.lived.potions = lived.getActivePotionEffects();
+        this.lived.loot = lived.getCanPickupItems();
+        this.lived.name = lived.getCustomName();
+        this.lived.visible = lived.isCustomNameVisible();
+        this.lived.health = (float) lived.getHealth();
+        this.lived.air = (short) lived.getRemainingAir();
+        this.lived.persistent = lived.getRemoveWhenFarAway();
+        this.lived.leashed = lived.isLeashed();
+        if (this.lived.leashed) {
+            Location location = lived.getLeashHolder().getLocation();
+            this.lived.leashX = (short) (this.x - location.getBlockX());
+            this.lived.leashY = (short) (this.y - location.getBlockY());
+            this.lived.leashZ = (short) (this.z - location.getBlockZ());
+        }
+        EntityEquipment equipment = lived.getEquipment();
+        this.lived.equipped = equipment != null;
+        if (this.lived.equipped) {
+            storeEquipment(equipment);
+        }
+    }
+
+    void storeEquipment(EntityEquipment equipment) {
+        this.lived.mainHand = equipment.getItemInMainHand().clone();
+        this.lived.offHand = equipment.getItemInOffHand().clone();
+        this.lived.boots = equipment.getBoots().clone();
+        this.lived.leggings = equipment.getLeggings().clone();
+        this.lived.chestplate = equipment.getChestplate().clone();
+        this.lived.helmet = equipment.getHelmet().clone();
+    }
+
+    private void restoreTameable(Tameable entity) {
+        if (this.tamed.tamed) {
+            if (this.tamed.owner != null) {
+                entity.setTamed(true);
+                entity.setOwner(this.tamed.owner);
+            }
+        }
+    }
+
+    private void restoreAgeable(Ageable entity) {
+        if (!this.aged.adult) {
+            entity.setBaby();
+        }
+        entity.setAgeLock(this.aged.locked);
+        if (this.aged.age > 0) {
+            entity.setAge(this.aged.age);
+        }
+    }
+
+    public void storeAgeable(Ageable aged) {
+        this.aged = new AgeableStats();
+        this.aged.age = aged.getAge();
+        this.aged.locked = aged.getAgeLock();
+        this.aged.adult = aged.isAdult();
+    }
+
+    public void storeTameable(Tameable tamed) {
+        this.tamed = new TameableStats();
+        this.tamed.owner = tamed.getOwner();
+        this.tamed.tamed = tamed.isTamed();
+    }
+
+    @Override public Entity spawn(World world, int xOffset, int zOffset) {
+        Location location = new Location(world, this.x + xOffset, this.y, this.z + zOffset);
+        location.setYaw(this.yaw);
+        location.setPitch(this.pitch);
+        if (!this.getType().isSpawnable()) {
+            return null;
+        }
+        Entity entity;
+        switch (this.getType()) {
+            case DROPPED_ITEM:
+                return world.dropItem(location, this.stack);
+            case PLAYER:
+            case LEASH_HITCH:
+                return null;
+            case ITEM_FRAME:
+                entity = world.spawn(location, ItemFrame.class);
+                break;
+            case PAINTING:
+                entity = world.spawn(location, Painting.class);
+                break;
+            default:
+                entity = world.spawnEntity(location, this.getType());
+                break;
+        }
+        if (this.depth == 0) {
+            return entity;
+        }
+        if (this.base.passenger != null) {
+            try {
+                entity.addPassenger(this.base.passenger.spawn(world, xOffset, zOffset));
+            } catch (Exception ignored) {
+            }
+        }
+        if (this.base.fall != 0) {
+            entity.setFallDistance(this.base.fall);
+        }
+        if (this.base.fire != 0) {
+            entity.setFireTicks(this.base.fire);
+        }
+        if (this.base.age != 0) {
+            entity.setTicksLived(this.base.age);
+        }
+        entity.setVelocity(new Vector(this.base.vX, this.base.vY, this.base.vZ));
+        if (this.depth == 1) {
+            return entity;
+        }
+        if (this.noGravity) {
+            entity.setGravity(false);
+        }
+        switch (entity.getType()) {
+            case BOAT:
+                Boat boat = (Boat) entity;
+                boat.setWoodType(TreeSpecies.values()[dataByte]);
+                return entity;
+            case SLIME:
+                ((Slime) entity).setSize(this.dataByte);
+                return entity;
+            case ARROW:
+            case EGG:
+            case ENDER_CRYSTAL:
+            case ENDER_PEARL:
+            case ENDER_SIGNAL:
+            case DROPPED_ITEM:
+            case EXPERIENCE_ORB:
+            case FALLING_BLOCK:
+            case FIREBALL:
+            case FIREWORK:
+            case FISHING_HOOK:
+            case LEASH_HITCH:
+            case LIGHTNING:
+            case MINECART:
+            case MINECART_COMMAND:
+            case MINECART_MOB_SPAWNER:
+            case MINECART_TNT:
+            case PLAYER:
+            case PRIMED_TNT:
+            case SMALL_FIREBALL:
+            case SNOWBALL:
+            case SPLASH_POTION:
+            case THROWN_EXP_BOTTLE:
+            case SPECTRAL_ARROW:
+            case SHULKER_BULLET:
+            case AREA_EFFECT_CLOUD:
+            case DRAGON_FIREBALL:
+            case WITHER_SKULL:
+            case MINECART_FURNACE:
+            case LLAMA_SPIT:
+            case TRIDENT:
+            case UNKNOWN:
+                // Do this stuff later
+                return entity;
+            // MISC //
+            case ITEM_FRAME:
+                ItemFrame itemframe = (ItemFrame) entity;
+                itemframe.setRotation(Rotation.values()[this.dataByte]);
+                itemframe.setItem(this.stack);
+                return entity;
+            case PAINTING:
+                Painting painting = (Painting) entity;
+                painting.setFacingDirection(BlockFace.values()[this.dataByte], true);
+                painting.setArt(Art.getByName(this.dataString), true);
+                return entity;
+            // END MISC //
+            // INVENTORY HOLDER //
+            case MINECART_CHEST:
+            case MINECART_HOPPER:
+                restoreInventory((InventoryHolder) entity);
+                return entity;
+            // START LIVING ENTITY //
+            // START AGEABLE //
+            // START TAMEABLE //
+            case HORSE:
+            case LLAMA:
+            case SKELETON_HORSE:
+            case DONKEY:
+            case MULE:
+                AbstractHorse horse = (AbstractHorse) entity;
+                horse.setJumpStrength(this.horse.jump);
+                if (horse instanceof ChestedHorse) {
+                    ((ChestedHorse) horse).setCarryingChest(this.horse.chest);
+                }
+                //todo broken as of 1.13
+                //horse.setVariant(this.horse.variant);
+                //horse.setStyle(this.horse.style);
+                //horse.setColor(this.horse.color);
+                restoreTameable(horse);
+                restoreAgeable(horse);
+                restoreLiving(horse);
+                restoreInventory(horse);
+                return entity;
+            // END INVENTORY HOLDER //
+            case WOLF:
+            case OCELOT:
+                restoreTameable((Tameable) entity);
+                restoreAgeable((Ageable) entity);
+                restoreLiving((LivingEntity) entity);
+                return entity;
+            // END AGEABLE //
+            case SHEEP:
+                Sheep sheep = (Sheep) entity;
+                if (this.dataByte == 1) {
+                    sheep.setSheared(true);
+                }
+                if (this.dataByte2 != 0) {
+                    sheep.setColor(DyeColor.getByDyeData(this.dataByte2));
+                }
+                restoreAgeable(sheep);
+                restoreLiving(sheep);
+                return sheep;
+            case VILLAGER:
+            case CHICKEN:
+            case COW:
+            case TURTLE:
+            case POLAR_BEAR:
+            case MUSHROOM_COW:
+            case PIG:
+                restoreAgeable((Ageable) entity);
+                restoreLiving((LivingEntity) entity);
+                return entity;
+            // END AGEABLE //
+            case RABBIT:
+                if (this.dataByte != 0) {
+                    ((Rabbit) entity).setRabbitType(Rabbit.Type.values()[this.dataByte]);
+                }
+                restoreAgeable((Ageable) entity);
+                restoreLiving((LivingEntity) entity);
+                return entity;
+            case ARMOR_STAND:
+                // CHECK positions
+                ArmorStand stand = (ArmorStand) entity;
+                if (this.inventory[0] != null) {
+                    stand.setItemInHand(this.inventory[0]);
+                }
+                if (this.inventory[1] != null) {
+                    stand.setHelmet(this.inventory[1]);
+                }
+                if (this.inventory[2] != null) {
+                    stand.setChestplate(this.inventory[2]);
+                }
+                if (this.inventory[3] != null) {
+                    stand.setLeggings(this.inventory[3]);
+                }
+                if (this.inventory[4] != null) {
+                    stand.setBoots(this.inventory[4]);
+                }
+                if (this.stand.head[0] != 0 || this.stand.head[1] != 0 || this.stand.head[2] != 0) {
+                    EulerAngle pose =
+                        new EulerAngle(this.stand.head[0], this.stand.head[1], this.stand.head[2]);
+                    stand.setHeadPose(pose);
+                }
+                if (this.stand.body[0] != 0 || this.stand.body[1] != 0 || this.stand.body[2] != 0) {
+                    EulerAngle pose =
+                        new EulerAngle(this.stand.body[0], this.stand.body[1], this.stand.body[2]);
+                    stand.setBodyPose(pose);
+                }
+                if (this.stand.leftLeg[0] != 0 || this.stand.leftLeg[1] != 0
+                    || this.stand.leftLeg[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.leftLeg[0], this.stand.leftLeg[1],
+                        this.stand.leftLeg[2]);
+                    stand.setLeftLegPose(pose);
+                }
+                if (this.stand.rightLeg[0] != 0 || this.stand.rightLeg[1] != 0
+                    || this.stand.rightLeg[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.rightLeg[0], this.stand.rightLeg[1],
+                        this.stand.rightLeg[2]);
+                    stand.setRightLegPose(pose);
+                }
+                if (this.stand.leftArm[0] != 0 || this.stand.leftArm[1] != 0
+                    || this.stand.leftArm[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.leftArm[0], this.stand.leftArm[1],
+                        this.stand.leftArm[2]);
+                    stand.setLeftArmPose(pose);
+                }
+                if (this.stand.rightArm[0] != 0 || this.stand.rightArm[1] != 0
+                    || this.stand.rightArm[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.rightArm[0], this.stand.rightArm[1],
+                        this.stand.rightArm[2]);
+                    stand.setRightArmPose(pose);
+                }
+                if (this.stand.invisible) {
+                    stand.setVisible(false);
+                }
+                if (this.stand.arms) {
+                    stand.setArms(true);
+                }
+                if (this.stand.noPlate) {
+                    stand.setBasePlate(false);
+                }
+                if (this.stand.small) {
+                    stand.setSmall(true);
+                }
+                restoreLiving(stand);
+                return stand;
+            case BAT:
+                if (this.dataByte != 0) {
+                    ((Bat) entity).setAwake(true);
+                }
+                restoreLiving((LivingEntity) entity);
+                return entity;
+            case ENDER_DRAGON:
+                if (this.dataByte != 0) {
+                    ((EnderDragon) entity).setPhase(EnderDragon.Phase.values()[this.dataByte]);
+                }
+                restoreLiving((LivingEntity) entity);
+                return entity;
+            case ENDERMITE:
+            case GHAST:
+            case MAGMA_CUBE:
+            case SQUID:
+            case PIG_ZOMBIE:
+            case ZOMBIE:
+            case WITHER:
+            case WITCH:
+            case SPIDER:
+            case CAVE_SPIDER:
+            case SILVERFISH:
+            case GIANT:
+            case ENDERMAN:
+            case CREEPER:
+            case BLAZE:
+            case SNOWMAN:
+            case SHULKER:
+            case GUARDIAN:
+            case ELDER_GUARDIAN:
+            case SKELETON:
+            case WITHER_SKELETON:
+                restoreLiving((LivingEntity) entity);
+                return entity;
+            case IRON_GOLEM:
+                if (this.dataByte != 0) {
+                    ((IronGolem) entity).setPlayerCreated(true);
+                }
+                restoreLiving((LivingEntity) entity);
+                return entity;
+            default:
+                PlotSquared.debug("&cCOULD NOT IDENTIFY ENTITY: " + entity.getType());
+                return entity;
+            // END LIVING
+        }
+    }
+
+    public void saveEntity() {
+    }
+
+    private byte getOrdinal(Object[] list, Object value) {
+        for (byte i = 0; i < list.length; i++) {
+            if (list[i].equals(value)) {
+                return i;
+            }
+        }
+        return 0;
+    }
+
+
+}

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,696 @@
+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.Set;
+import java.util.concurrent.CompletableFuture;
+
+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 : 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);
+        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());
+        World world2 = Bukkit.getWorld(bot2.getWorld());
+
+        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 objects = MainCommand.getInstance().tab(player, args, s.endsWith(" "));
+        if (objects == null) {
+            return null;
+        }
+        List<String> result = new ArrayList<>();
+        for (Object 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,133 @@
+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.util.EventUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+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();
+    }
+}

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

@@ -0,0 +1,124 @@
+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 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;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.inventory.meta.ItemMeta;
+
+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;
+    Inventory inventory = Bukkit.createInventory(null, inv.size * 9, inv.getTitle());
+    PlotItemStack[] items = inv.getItems();
+    for (int i = 0; i < inv.size * 9; i++) {
+      PlotItemStack item = items[i];
+      if (item != null) {
+        inventory.setItem(i, getItem(item));
+      }
+    }
+    bp.player.openInventory(inventory);
+  }
+
+  @Override public void close(PlotInventory inv) {
+    if (!inv.isOpen()) {
+      return;
+    }
+    BukkitPlayer bp = (BukkitPlayer) inv.player;
+    bp.player.closeInventory();
+  }
+
+  @Override public void setItem(PlotInventory inv, int index, PlotItemStack item) {
+    BukkitPlayer bp = (BukkitPlayer) inv.player;
+    InventoryView opened = bp.player.getOpenInventory();
+    if (!inv.isOpen()) {
+      return;
+    }
+    opened.setItem(index, getItem(item));
+    bp.player.updateInventory();
+  }
+
+  private static ItemStack getItem(PlotItemStack item) {
+    if (item == null) {
+      return null;
+    }
+    ItemStack stack = new ItemStack(BukkitUtil.getMaterial(item.getBlockState()), item.amount);
+    ItemMeta meta = null;
+    if (item.name != null) {
+      meta = stack.getItemMeta();
+      meta.setDisplayName(ChatColor.translateAlternateColorCodes('&', item.name));
+    }
+    if (item.lore != null) {
+      if (meta == null) {
+        meta = stack.getItemMeta();
+      }
+      List<String> lore = new ArrayList<>();
+      for (String entry : item.lore) {
+        lore.add(ChatColor.translateAlternateColorCodes('&', entry));
+      }
+      meta.setLore(lore);
+    }
+    if (meta != null) {
+      stack.setItemMeta(meta);
+    }
+    return stack;
+  }
+
+  public PlotItemStack getItem(ItemStack item) {
+    if (item == null) {
+      return null;
+    }
+    // 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();
+        lore = itemLore.toArray(new String[0]);
+      }
+    }
+    return new PlotItemStack(id.name(), amount, name, lore);
+  }
+
+  @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) plotInventory.player;
+    InventoryView opened = bp.player.getOpenInventory();
+    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,445 @@
+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 PlotPlayer player) {
+        return getLocation(((BukkitPlayer) player).player.getBedSpawnLocation());
+    }
+
+    @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,7 @@
+package com.github.intellectualsites.plotsquared.bukkit.util;
+
+public class BukkitVersion {
+    public static int[] v1_13_2 = {1, 13, 2};
+    public static int[] v1_13_1 = {1, 13, 1};
+    public static int[] v1_13_0 = {1, 13, 0};
+}

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

@@ -0,0 +1,708 @@
+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;
+
+    // A list with all custom charts
+    private final List<CustomChart> charts = new ArrayList<>();
+
+    /**
+     * Class constructor.
+     *
+     * @param plugin The plugin which stats should be submitted.
+     */
+    public Metrics(Plugin plugin) {
+        if (plugin == null) {
+            throw new IllegalArgumentException("Plugin cannot be null!");
+        }
+        this.plugin = plugin;
+
+        // 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("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,250 @@
+package com.github.intellectualsites.plotsquared.bukkit.uuid;
+
+import com.github.intellectualsites.plotsquared.bukkit.util.NbtFactory;
+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 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);
+    }
+
+    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);
+                                NbtFactory.NbtCompound compound = NbtFactory
+                                    .fromStream(new FileInputStream(file),
+                                        NbtFactory.StreamOptions.GZIP_COMPRESSION);
+                                if (!compound.containsKey("bukkit")) {
+                                    PlotSquared.debug("ERROR: Player data (" + uuid.toString()
+                                        + ".dat) does not contain the the key \"bukkit\"");
+                                } else {
+                                    NbtFactory.NbtCompound bukkit =
+                                        (NbtFactory.NbtCompound) compound.get("bukkit");
+                                    String name = (String) bukkit.get("lastKnownName");
+                                    long last = (long) bukkit.get("lastPlayed");
+                                    long first = (long) bukkit.get("firstPlayed");
+                                    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;
+                    }
+                    NbtFactory.NbtCompound compound = NbtFactory
+                        .fromStream(new FileInputStream(file),
+                            NbtFactory.StreamOptions.GZIP_COMPRESSION);
+                    if (!compound.containsKey("bukkit")) {
+                        PlotSquared.debug("ERROR: Player data (" + uuid.toString()
+                            + ".dat) does not contain the the key \"bukkit\"");
+                    } else {
+                        NbtFactory.NbtCompound bukkit =
+                            (NbtFactory.NbtCompound) compound.get("bukkit");
+                        String name = (String) bukkit.get("lastKnownName");
+                        StringWrapper wrap = new StringWrapper(name);
+                        if (!toAdd.containsKey(wrap)) {
+                            long last = (long) bukkit.get("lastPlayed");
+                            long first = (long) bukkit.get("firstPlayed");
+                            if (Settings.UUID.OFFLINE) {
+                                if (Settings.UUID.FORCE_LOWERCASE && !name.toLowerCase()
+                                    .equals(name)) {
+                                    uuid = FileUUIDHandler.this.uuidWrapper.getUUID(name);
+                                } else {
+                                    long most = (long) compound.get("UUIDMost");
+                                    long least = (long) compound.get("UUIDLeast");
+                                    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,32 @@
+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.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:" + 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,246 @@
+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 class SQLUUIDHandlerException extends RuntimeException {
+
+        SQLUUIDHandlerException(String s, Throwable c) {
+            super("SQLUUIDHandler caused an exception: " + s, c);
+        }
+    }
+}

Bukkit/src/main/java/com/intellectualcrafters/plot/api/PlotAPI.java

@@ -1,758 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// PlotSquared - A plot manager and world generator for the Bukkit API                             /
-// Copyright (c) 2014 IntellectualSites/IntellectualCrafters                                       /
-//                                                                                                 /
-// This program is free software; you can redistribute it and/or modify                            /
-// it under the terms of the GNU General Public License as published by                            /
-// the Free Software Foundation; either version 3 of the License, or                               /
-// (at your option) any later version.                                                             /
-//                                                                                                 /
-// This program is distributed in the hope that it will be useful,                                 /
-// but WITHOUT ANY WARRANTY; without even the implied warranty of                                  /
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                   /
-// GNU General Public License for more details.                                                    /
-//                                                                                                 /
-// You should have received a copy of the GNU General Public License                               /
-// along with this program; if not, write to the Free Software Foundation,                         /
-// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA                               /
-//                                                                                                 /
-// You can contact us via: support@intellectualsites.com                                           /
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-package com.intellectualcrafters.plot.api;
-
-import com.intellectualcrafters.configuration.file.YamlConfiguration;
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.commands.MainCommand;
-import com.intellectualcrafters.plot.commands.SubCommand;
-import com.intellectualcrafters.plot.config.C;
-import com.intellectualcrafters.plot.flag.AbstractFlag;
-import com.intellectualcrafters.plot.flag.FlagManager;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotArea;
-import com.intellectualcrafters.plot.object.PlotId;
-import com.intellectualcrafters.plot.object.PlotManager;
-import com.intellectualcrafters.plot.object.PlotPlayer;
-import com.intellectualcrafters.plot.util.ChunkManager;
-import com.intellectualcrafters.plot.util.MainUtil;
-import com.intellectualcrafters.plot.util.SchematicHandler;
-import com.intellectualcrafters.plot.util.SetQueue;
-import com.intellectualcrafters.plot.util.UUIDHandler;
-import com.intellectualcrafters.plot.uuid.UUIDWrapper;
-import com.plotsquared.bukkit.util.BukkitUtil;
-import org.bukkit.Location;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * PlotSquared API
- *
-
-
- * @version API 2.0
- *
- */
-
-public class PlotAPI {
-    
-    /**
-     * Permission that allows for admin access, this permission node will allow the player to use any part of the
-     * plugin, without limitations.
-     * @deprecated Use C.PERMISSION_ADMIN.s() instead
-     */
-    @Deprecated
-    public static final String ADMIN_PERMISSION = C.PERMISSION_ADMIN.s();
-    
-    /**
-     * @deprecated Use new PlotAPI() instead
-     */
-    @Deprecated
-    public PlotAPI(final JavaPlugin plugin) {}
-    
-    /**
-     * @see PS
-     *
-     * @deprecated Use this class if you just want to do a few simple things.<br>
-     *  - It will remain stable for future versions of the plugin
-     *  - The PlotPlayer and Plot class should be considered relatively safe
-     *  - For more advanced/intensive tasks you should consider using other classes
-     *
-     *
-     */
-    @Deprecated
-    public PlotAPI() {}
-    
-    /**
-     * Get all plots
-     *
-     * @return all plots
-     *
-     * @see PS#getPlots()
-     */
-    public Set<Plot> getAllPlots() {
-        return PS.get().getPlots();
-    }
-    
-    /**
-     * Return all plots for a player
-     *
-     * @param player Player, whose plots to search for
-     *
-     * @return all plots that a player owns
-     */
-    public Set<Plot> getPlayerPlots(final Player player) {
-        return PS.get().getPlots(BukkitUtil.getPlayer(player));
-    }
-    
-    /**
-     * Add a plot world
-     *
-     * @param plotArea Plot World Object
-     * @see PS#addPlotArea(PlotArea)
-     */
-    public void addPlotArea(final PlotArea plotArea) {
-        PS.get().addPlotArea(plotArea);
-    }
-    
-    /**
-     * @return main configuration
-     *
-     * @see PS#config
-     */
-    public YamlConfiguration getConfig() {
-        return PS.get().config;
-    }
-    
-    /**
-     * @return storage configuration
-     *
-     * @see PS#storage
-     */
-    public YamlConfiguration getStorage() {
-        return PS.get().storage;
-    }
-    
-    /**
-     * Get the main class for this plugin <br> - Contains a lot of fields and methods - not very well organized <br>
-     * Only use this if you really need it
-     *
-     * @return PlotSquared PlotSquared Main Class
-     *
-     * @see PS
-     */
-    public PS getMain() {
-        return PS.get();
-    }
-    
-    /**
-     * ChunkManager class contains several useful methods<br>
-     *  - Chunk deletion<br>
-     *  - Moving or copying regions<br>
-     *  - plot swapping<br>
-     *  - Entity tracking<br>
-     *  - region regeneration<br>
-     *
-     * @return ChunkManager
-     *
-     * @see com.intellectualcrafters.plot.util.ChunkManager
-     */
-    public ChunkManager getChunkManager() {
-        return ChunkManager.manager;
-    }
-
-    /**
-     * Get the block/biome set queue
-     * @return SetQueue.IMP
-     */
-    public SetQueue getSetQueue() {
-        return SetQueue.IMP;
-    }
-    
-    /**
-     * UUIDWrapper class has basic methods for getting UUIDS (it's recommended to use the UUIDHandler class instead)
-     *
-     * @return UUIDWrapper
-     *
-     * @see com.intellectualcrafters.plot.uuid.UUIDWrapper
-     */
-    public UUIDWrapper getUUIDWrapper() {
-        return UUIDHandler.getUUIDWrapper();
-    }
-    
-    /**
-     * Do not use this. Instead use FlagManager.[method] in your code.
-     *  - Flag related stuff
-     *
-     * @return FlagManager
-     *
-     * @see com.intellectualcrafters.plot.flag.FlagManager
-     */
-    @Deprecated
-    public FlagManager getFlagManager() {
-        return new FlagManager();
-    }
-    
-    /**
-     * Do not use this. Instead use MainUtil.[method] in your code.
-     *  - Basic plot management stuff
-     *
-     * @return MainUtil
-     *
-     * @see MainUtil
-     */
-    @Deprecated
-    public MainUtil getMainUtil() {
-        return new MainUtil();
-    }
-    
-    /**
-     * Do not use this. Instead use C.PERMISSION_[method] in your code.
-     *  - Basic permission management stuff
-     *
-     * @return Array of strings
-     *
-     * @see com.intellectualcrafters.plot.util.Permissions
-     */
-    @Deprecated
-    public String[] getPermissions() {
-        final ArrayList<String> perms = new ArrayList<>();
-        for (final C c : C.values()) {
-            if ("static.permissions".equals(c.getCat())) {
-                perms.add(c.s());
-            }
-        }
-        return perms.toArray(new String[perms.size()]);
-    }
-    
-    /**
-     * SchematicHandler class contains methods related to pasting, reading and writing schematics
-     *
-     * @return SchematicHandler
-     *
-     * @see com.intellectualcrafters.plot.util.SchematicHandler
-     */
-    public SchematicHandler getSchematicHandler() {
-        return SchematicHandler.manager;
-    }
-    
-    /**
-     * Use C.[caption] instead
-     *
-     * @return C
-     *
-     * @see com.intellectualcrafters.plot.config.C
-     */
-    @Deprecated
-    public C[] getCaptions() {
-        return C.values();
-    }
-    
-    /**
-     * Get the plot manager for a world. - Most of these methods can be accessed through the MainUtil
-     *
-     * @param world Which manager to get
-     *
-     * @return PlotManager
-     *
-     * @see com.intellectualcrafters.plot.object.PlotManager
-     * @see PS#getPlotManager(Plot)
-     */
-    @Deprecated
-    public PlotManager getPlotManager(final World world) {
-        if (world == null) {
-            return null;
-        }
-        return getPlotManager(world.getName());
-    }
-    
-    public Set<PlotArea> getPlotAreas(World world) {
-        if (world == null) {
-            return new HashSet<>();
-        }
-        return PS.get().getPlotAreas(world.getName());
-    }
-
-    /**
-     * Get the plot manager for a world. - Contains useful low level methods for plot merging, clearing, and
-     * tessellation
-     *
-     * @param world
-     *
-     * @return PlotManager
-     *
-     * @see PS#getPlotManager(Plot)
-     * @see com.intellectualcrafters.plot.object.PlotManager
-     */
-    @Deprecated
-    public PlotManager getPlotManager(final String world) {
-        Set<PlotArea> areas = PS.get().getPlotAreas(world);
-        switch (areas.size()) {
-            case 0:
-                return null;
-            case 1:
-                return areas.iterator().next().manager;
-            default:
-                PS.debug("PlotAPI#getPlotManager(org.bukkit.World) is deprecated and doesn't support multi plot area worlds.");
-                return null;
-        }
-    }
-    
-    /**
-     * Get the settings for a world (settings bundled in PlotArea class) - You will need to downcast for the specific
-     * settings a Generator has. e.g. DefaultPlotWorld class implements PlotArea
-     *
-     * @param world (to get settings of)
-     *
-     * @return PlotArea class for that world ! will return null if not a plot world world
-     *
-     * @see #getPlotAreas(World)
-     * @see com.intellectualcrafters.plot.object.PlotArea
-     */
-    @Deprecated
-    public PlotArea getWorldSettings(final World world) {
-        if (world == null) {
-            return null;
-        }
-        return getWorldSettings(world.getName());
-    }
-    
-    /**
-     * Get the settings for a world (settings bundled in PlotArea class)
-     *
-     * @param world (to get settings of)
-     *
-     * @return PlotArea class for that world ! will return null if not a plot world world
-     *
-     * @see PS#getPlotArea(String, String)
-     * @see com.intellectualcrafters.plot.object.PlotArea
-     */
-    @Deprecated
-    public PlotArea getWorldSettings(final String world) {
-        if (world == null) {
-            return null;
-        }
-        Set<PlotArea> areas = PS.get().getPlotAreas(world);
-        switch (areas.size()) {
-            case 0:
-                return null;
-            case 1:
-                return areas.iterator().next();
-            default:
-                PS.debug("PlotAPI#getWorldSettings(org.bukkit.World) is deprecated and doesn't support multi plot area worlds.");
-                return null;
-        }
-    }
-    
-    /**
-     * Send a message to a player.
-     *
-     * @param player Player that will receive the message
-     * @param c      (Caption)
-     *
-     * @see MainUtil#sendMessage(PlotPlayer, C, String...)
-     * com.intellectualcrafters.plot.config.C, String...)
-     */
-    public void sendMessage(final Player player, final C c) {
-        MainUtil.sendMessage(BukkitUtil.getPlayer(player), c);
-    }
-    
-    /**
-     * Send a message to a player. - Supports color codes
-     *
-     * @param player Player that will receive the message
-     * @param string The message
-     *
-     * @see MainUtil#sendMessage(PlotPlayer, String)
-     */
-    public void sendMessage(final Player player, final String string) {
-        MainUtil.sendMessage(BukkitUtil.getPlayer(player), string);
-    }
-    
-    /**
-     * Send a message to the console. - Supports color codes
-     *
-     * @param msg Message that should be sent to the console
-     *
-     * @see MainUtil#sendConsoleMessage(C, String...)
-     */
-    public void sendConsoleMessage(final String msg) {
-        PS.log(msg);
-    }
-    
-    /**
-     * Send a message to the console
-     *
-     * @param c (Caption)
-     *
-     * @see #sendConsoleMessage(String)
-     * @see com.intellectualcrafters.plot.config.C
-     */
-    public void sendConsoleMessage(final C c) {
-        sendConsoleMessage(c.s());
-    }
-    
-    /**
-     * Register a flag for use in plots
-     *
-     * @param flag Flag that should be registered
-     *
-     * @see com.intellectualcrafters.plot.flag.FlagManager#addFlag(com.intellectualcrafters.plot.flag.AbstractFlag)
-     * @see com.intellectualcrafters.plot.flag.AbstractFlag
-     */
-    public void addFlag(final AbstractFlag flag) {
-        FlagManager.addFlag(flag);
-    }
-    
-    /**
-     * get all the currently registered flags
-     *
-     * @return array of Flag[]
-     *
-     * @see com.intellectualcrafters.plot.flag.FlagManager#getFlags()
-     * @see com.intellectualcrafters.plot.flag.AbstractFlag
-     */
-    public AbstractFlag[] getFlags() {
-        return FlagManager.getFlags().toArray(new AbstractFlag[FlagManager.getFlags().size()]);
-    }
-    
-    /**
-     * Get a plot based on the ID
-     *
-     * @param world World in which the plot is located
-     * @param x     Plot Location X Co-ord
-     * @param z     Plot Location Z Co-ord
-     *
-     * @return plot, null if ID is wrong
-     *
-     * @see PlotArea#getPlot(PlotId)
-     */
-    @Deprecated
-    public Plot getPlot(final World world, final int x, final int z) {
-        if (world == null) {
-            return null;
-        }
-        PlotArea area = getWorldSettings(world);
-        if (area == null) {
-            return null;
-        }
-        return area.getPlot(new PlotId(x, z));
-    }
-    
-    /**
-     * Get a plot based on the location
-     *
-     * @param l The location that you want to to retrieve the plot from
-     *
-     * @return plot if found, otherwise it creates a temporary plot-
-     *
-     * @see Plot
-     */
-    public Plot getPlot(final Location l) {
-        if (l == null) {
-            return null;
-        }
-        return BukkitUtil.getLocation(l).getPlot();
-    }
-    
-    /**
-     * Get a plot based on the player location
-     *
-     * @param player Get the current plot for the player location
-     *
-     * @return plot if found, otherwise it creates a temporary plot
-     *
-     * @see #getPlot(org.bukkit.Location)
-     * @see Plot
-     */
-    public Plot getPlot(final Player player) {
-        return this.getPlot(player.getLocation());
-    }
-    
-    /**
-     * Check whether or not a player has a plot
-     *
-     * @param player Player that you want to check for
-     *
-     * @return true if player has a plot, false if not.
-     *
-     * @see #getPlots(World, Player, boolean)
-     */
-    @Deprecated
-    public boolean hasPlot(final World world, final Player player) {
-        return getPlots(world, player, true) != null && getPlots(world, player, true).length > 0;
-    }
-    
-    /**
-     * Get all plots for the player
-     *
-     * @param plr        to search for
-     * @param just_owner should we just search for owner? Or with rights?
-     */
-    @Deprecated
-    public Plot[] getPlots(final World world, final Player plr, final boolean just_owner) {
-        final ArrayList<Plot> pPlots = new ArrayList<>();
-        UUID uuid = BukkitUtil.getPlayer(plr).getUUID();
-        for (final Plot plot : PS.get().getPlots(world.getName())) {
-            if (just_owner) {
-                if (plot.hasOwner() && plot.isOwner(uuid)) {
-                    pPlots.add(plot);
-                }
-            } else {
-                if (plot.isAdded(uuid)) {
-                    pPlots.add(plot);
-                }
-            }
-        }
-        return pPlots.toArray(new Plot[pPlots.size()]);
-    }
-    
-    /**
-     * Get all plots for the world
-     *
-     * @param world to get plots of
-     *
-     * @return Plot[] - array of plot objects in world
-     *
-     * @see PS#getPlots(String)
-     * @see Plot
-     */
-    @Deprecated
-    public Plot[] getPlots(final World world) {
-        if (world == null) {
-            return new Plot[0];
-        }
-        Collection<Plot> plots = PS.get().getPlots(world.getName());
-        return plots.toArray(new Plot[plots.size()]);
-    }
-    
-    /**
-     * Get all plot worlds
-     *
-     * @return World[] - array of plot worlds
-     *
-     */
-    @Deprecated
-    public String[] getPlotWorlds() {
-        Set<String> plotWorldStrings = PS.get().getPlotWorldStrings();
-        return plotWorldStrings.toArray(new String[plotWorldStrings.size()]);
-    }
-    
-    /**
-     * Get if plot world
-     *
-     * @param world (to check if plot world)
-     *
-     * @return boolean (if plot world or not)
-     *
-     * @see PS#hasPlotArea(String)
-     */
-    @Deprecated
-    public boolean isPlotWorld(final World world) {
-        return PS.get().hasPlotArea(world.getName());
-    }
-    
-    /**
-     * Get plot locations
-     *
-     * @param p Plot that you want to get the locations for
-     *
-     * @return [0] = bottomLc, [1] = topLoc, [2] = home
-     *
-     * @deprecated As merged plots may not have a rectangular shape
-     *
-     * @see Plot
-     */
-    @Deprecated
-    public Location[] getLocations(final Plot p) {
-        return new Location[] { BukkitUtil.getLocation(p.getBottom()), BukkitUtil.getLocation(p.getTop()), BukkitUtil.getLocation(p.getHome()) };
-    }
-    
-    /**
-     * Get home location
-     *
-     * @param p Plot that you want to get the location for
-     *
-     * @return plot bottom location
-     *
-     * @see Plot
-     */
-    public Location getHomeLocation(final Plot p) {
-        return BukkitUtil.getLocation(p.getHome());
-    }
-    
-    /**
-     * Get Bottom Location (min, min, min)
-     *
-     * @param p Plot that you want to get the location for
-     *
-     * @return plot bottom location
-     *
-     * @deprecated As merged plots may not have a rectangular shape
-     *
-     * @see Plot
-     */
-    @Deprecated
-    public Location getBottomLocation(final Plot p) {
-        return BukkitUtil.getLocation(p.getBottom());
-    }
-    
-    /**
-     * Get Top Location (max, max, max)
-     *
-     * @param p Plot that you want to get the location for
-     *
-     * @return plot top location
-     * 
-     * @deprecated As merged plots may not have a rectangular shape
-     *
-     * @see Plot
-     */
-    @Deprecated
-    public Location getTopLocation(final Plot p) {
-        return BukkitUtil.getLocation(p.getTop());
-    }
-    
-    /**
-     * 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 boolean isInPlot(final Player player) {
-        return getPlot(player) != null;
-    }
-    
-    /**
-     * Register a subcommand
-     *
-     * @param c SubCommand, that we want to register
-     *
-     * @see com.intellectualcrafters.plot.commands.SubCommand
-     */
-    public void registerCommand(final SubCommand c) {
-        if (c.getCommand() != null) {
-            MainCommand.getInstance().addCommand(c);
-        } else {
-            MainCommand.getInstance().createCommand(c);
-        }
-    }
-    
-    /**
-     * Get the PlotSquared class
-     *
-     * @return PlotSquared Class
-     *
-     * @see PS
-     */
-    public PS getPlotSquared() {
-        return PS.get();
-    }
-    
-    /**
-     * Get 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 int getPlayerPlotCount(final World world, final Player player) {
-        if (world == null) {
-            return 0;
-        }
-        return BukkitUtil.getPlayer(player).getPlotCount(world.getName());
-    }
-    
-    /**
-     * Get 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 PS#getPlots(String, PlotPlayer)
-     *
-     * @see Plot
-     */
-    public Set<Plot> getPlayerPlots(final World world, final Player player) {
-        if (world == null) {
-            return new HashSet<>();
-        }
-        return BukkitUtil.getPlayer(player).getPlots(world.getName());
-    }
-    
-    /**
-     * Get the numbers of plots, which the player is able to build in
-     *
-     * @param player Player, for whom we're getting the plots (trusted, member and owner)
-     *
-     * @return the number of allowed plots
-     *
-     */
-    public int getAllowedPlots(final Player player) {
-        final PlotPlayer pp = BukkitUtil.getPlayer(player);
-        return pp.getAllowedPlots();
-    }
-    
-    /**
-     * Get the PlotPlayer for a player<br>
-     *  - The PlotPlayer is usually cached and will provide useful functions relating to players
-     *
-     * @see PlotPlayer#wrap(Object)
-     *
-     * @param player
-     * @return
-     */
-    public PlotPlayer wrapPlayer(final Player player) {
-        return PlotPlayer.wrap(player);
-    }
-    
-    /**
-     * Get the PlotPlayer for a UUID (Please note that PlotSquared can be configured to provide different UUIDs than bukkit)
-     *
-     * @see PlotPlayer#wrap(Object)
-     *
-     * @param uuid
-     * @return
-     */
-    public PlotPlayer wrapPlayer(final UUID uuid) {
-        return PlotPlayer.wrap(uuid);
-    }
-    
-    /**
-     * Get the PlotPlayer for a username
-     *
-     * @see PlotPlayer#wrap(Object)
-     *
-     * @param player
-     * @return
-     */
-    public PlotPlayer wrapPlayer(final String player) {
-        return PlotPlayer.wrap(player);
-    }
-    
-    /**
-     * Get the PlotPlayer for an offline player<br>
-     * Note that this will work if the player is offline, however not all functionality will work
-     *
-     * @see PlotPlayer#wrap(Object)
-     *
-     * @param player
-     * @return
-     */
-    public PlotPlayer wrapPlayer(final OfflinePlayer player) {
-        return PlotPlayer.wrap(player);
-    }
-}

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

@@ -1,645 +0,0 @@
-package com.plotsquared.bukkit;
-
-import com.intellectualcrafters.configuration.ConfigurationSection;
-import com.intellectualcrafters.plot.IPlotMain;
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.commands.MainCommand;
-import com.intellectualcrafters.plot.config.C;
-import com.intellectualcrafters.plot.config.ConfigurationNode;
-import com.intellectualcrafters.plot.config.Settings;
-import com.intellectualcrafters.plot.flag.FlagManager;
-import com.intellectualcrafters.plot.generator.GeneratorWrapper;
-import com.intellectualcrafters.plot.generator.HybridGen;
-import com.intellectualcrafters.plot.generator.HybridUtils;
-import com.intellectualcrafters.plot.generator.IndependentPlotGenerator;
-import com.intellectualcrafters.plot.object.*;
-import com.intellectualcrafters.plot.util.*;
-import com.intellectualcrafters.plot.uuid.UUIDWrapper;
-import com.plotsquared.bukkit.commands.DebugUUID;
-import com.plotsquared.bukkit.database.plotme.ClassicPlotMeConnector;
-import com.plotsquared.bukkit.database.plotme.LikePlotMeConverter;
-import com.plotsquared.bukkit.database.plotme.PlotMeConnector_017;
-import com.plotsquared.bukkit.generator.BukkitPlotGenerator;
-import com.plotsquared.bukkit.listeners.*;
-import com.plotsquared.bukkit.listeners.worldedit.WEListener;
-import com.plotsquared.bukkit.titles.DefaultTitle;
-import com.plotsquared.bukkit.util.*;
-import com.plotsquared.bukkit.util.block.FastQueue_1_7;
-import com.plotsquared.bukkit.util.block.FastQueue_1_8;
-import com.plotsquared.bukkit.util.block.FastQueue_1_8_3;
-import com.plotsquared.bukkit.util.block.SlowQueue;
-import com.plotsquared.bukkit.uuid.*;
-import com.sk89q.worldedit.bukkit.WorldEditPlugin;
-import org.bukkit.*;
-import org.bukkit.Location;
-import org.bukkit.command.PluginCommand;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-import org.bukkit.event.Listener;
-import org.bukkit.generator.ChunkGenerator;
-import org.bukkit.metadata.MetadataValue;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import java.io.File;
-import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.*;
-
-public class BukkitMain extends JavaPlugin implements Listener, IPlotMain {
-    
-    public static BukkitMain THIS;
-    public static WorldEditPlugin worldEdit;
-    
-    private int[] version;
-    
-    @Override
-    public int[] getServerVersion() {
-        if (version == null) {
-            try {
-                version = new int[3];
-                final String[] split = Bukkit.getBukkitVersion().split("-")[0].split("\\.");
-                version[0] = Integer.parseInt(split[0]);
-                version[1] = Integer.parseInt(split[1]);
-                if (split.length == 3) {
-                    version[2] = Integer.parseInt(split[2]);
-                }
-            } catch (NumberFormatException e) {
-                e.printStackTrace();
-                PS.debug(StringMan.getString(Bukkit.getBukkitVersion()));
-                PS.debug(StringMan.getString(Bukkit.getBukkitVersion().split("-")[0].split("\\.")));
-                return new int[]{Integer.MAX_VALUE, 0, 0};
-            }
-        }
-        return version;
-    }
-    
-    @Override
-    public void onEnable() {
-        THIS = this;
-        new PS(this, "Bukkit");
-    }
-    
-    @Override
-    public void onDisable() {
-        PS.get().disable();
-        Bukkit.getScheduler().cancelTasks(this);
-        THIS = null;
-    }
-    
-    @Override
-    public void log(String message) {
-        if (message == null) {
-            return;
-        }
-        if ((THIS != null) && (Bukkit.getServer().getConsoleSender() != null)) {
-            try {
-                message = C.color(message);
-                if (!Settings.CONSOLE_COLOR) {
-                    message = ChatColor.stripColor(message);
-                }
-                Bukkit.getServer().getConsoleSender().sendMessage(message);
-                return;
-            } catch (final Throwable e) {}
-        }
-        System.out.println(ConsoleColors.fromString(message));
-    }
-    
-    @Override
-    public void disable() {
-        if (THIS != null) {
-            onDisable();
-        }
-    }
-    
-    @Override
-    public int[] getPluginVersion() {
-        final String[] split = getDescription().getVersion().split("\\.");
-        return new int[] { Integer.parseInt(split[0]), Integer.parseInt(split[1]), Integer.parseInt(split[2]) };
-    }
-    
-    @Override
-    public void registerCommands() {
-        final BukkitCommand bcmd = new BukkitCommand();
-        final PluginCommand plotCommand = getCommand("plots");
-        plotCommand.setExecutor(bcmd);
-        plotCommand.setAliases(Arrays.asList("p", "ps", "plotme", "plot"));
-        plotCommand.setTabCompleter(bcmd);
-        MainCommand.getInstance().addCommand(new DebugUUID());
-    }
-    
-    @Override
-    public File getDirectory() {
-        return getDataFolder();
-    }
-    
-    @Override
-    public File getWorldContainer() {
-        return Bukkit.getWorldContainer();
-    }
-    
-    @Override
-    public TaskManager getTaskManager() {
-        return new BukkitTaskManager();
-    }
-    
-    @Override
-    public void runEntityTask() {
-        log(C.PREFIX.s() + "KillAllEntities started.");
-        TaskManager.runTaskRepeat(new Runnable() {
-            @Override
-            public void run() {
-                PS.get().foreachPlotArea(new RunnableVal<PlotArea>() {
-                    @Override
-                    public void run(PlotArea pw) {
-                        World world = Bukkit.getWorld(pw.worldname);
-                        try {
-                            if (world == null) {
-                                return;
-                            }
-                            List<Entity> entities = world.getEntities();
-                            Iterator<Entity> iter = entities.iterator();
-                            while (iter.hasNext()) {
-                                Entity entity = iter.next();
-                                switch (entity.getType()) {
-                                    case EGG:
-                                    case ENDER_CRYSTAL:
-                                    case COMPLEX_PART:
-                                    case FISHING_HOOK:
-                                    case ENDER_SIGNAL:
-                                    case EXPERIENCE_ORB:
-                                    case LEASH_HITCH:
-                                    case FIREWORK:
-                                    case WEATHER:
-                                    case LIGHTNING:
-                                    case WITHER_SKULL:
-                                    case UNKNOWN:
-                                    case PLAYER: {
-                                        // non moving / unremovable
-                                        continue;
-                                    }
-                                    case THROWN_EXP_BOTTLE:
-                                    case SPLASH_POTION:
-                                    case SNOWBALL:
-                                    case ENDER_PEARL:
-                                    case ARROW: {
-                                        // managed elsewhere | projectile
-                                        continue;
-                                    }
-                                    case ARMOR_STAND:
-                                    case ITEM_FRAME:
-                                    case PAINTING: {
-                                        // TEMPORARILY CLASSIFY AS VEHICLE
-                                    }
-                                    case MINECART:
-                                    case MINECART_CHEST:
-                                    case MINECART_COMMAND:
-                                    case MINECART_FURNACE:
-                                    case MINECART_HOPPER:
-                                    case MINECART_MOB_SPAWNER:
-                                    case MINECART_TNT:
-                                    case BOAT: {
-                                        if (!Settings.KILL_ROAD_VEHICLES) {
-                                            continue;
-                                        }
-                                        com.intellectualcrafters.plot.object.Location loc = BukkitUtil.getLocation(entity.getLocation());
-                                        Plot plot = loc.getPlot();
-                                        if (plot == null) {
-                                            if (loc.isPlotArea()) {
-                                                iter.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))) {
-                                            iter.remove();
-                                            entity.remove();
-                                        }
-                                        continue;
-                                    }
-                                    case SMALL_FIREBALL:
-                                    case FIREBALL:
-                                    case DROPPED_ITEM: {
-                                        // dropped item
-                                        continue;
-                                    }
-                                    case PRIMED_TNT:
-                                    case FALLING_BLOCK: {
-                                        // managed elsewhere
-                                        continue;
-                                    }
-                                    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:
-                                    default: {
-                                        if (!Settings.KILL_ROAD_MOBS) {
-                                            continue;
-                                        }
-                                        final Location loc = entity.getLocation();
-                                        if (BukkitUtil.getLocation(loc).isPlotRoad()) {
-                                            final Entity passenger = entity.getPassenger();
-                                            if (!(passenger instanceof Player)) {
-                                                if (entity.getMetadata("keep").isEmpty()) {
-                                                    iter.remove();
-                                                    entity.remove();
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        } catch (final Throwable e) {
-                            e.printStackTrace();
-                        }
-                    }
-                });
-            }
-        }, 20);
-    }
-    
-    @Override
-    final public ChunkGenerator getDefaultWorldGenerator(final String world, final String id) {
-        final HybridGen result = new HybridGen();
-        if (!PS.get().setupPlotWorld(world, id, result)) {
-            return null;
-        }
-        return (ChunkGenerator) result.specify();
-    }
-    
-    @Override
-    public void registerPlayerEvents() {
-        getServer().getPluginManager().registerEvents(new PlayerEvents(), this);
-        if (PS.get().checkVersion(getServerVersion(), 1, 8, 0)) {
-            getServer().getPluginManager().registerEvents(new PlayerEvents_1_8(), this);
-        }
-        if (PS.get().checkVersion(getServerVersion(), 1, 8, 3)) {
-            getServer().getPluginManager().registerEvents(new PlayerEvents_1_8_3(), this);
-        }
-    }
-    
-    @Override
-    public void registerInventoryEvents() {
-        // Part of PlayerEvents - can be moved if necessary
-    }
-    
-    @Override
-    public void registerPlotPlusEvents() {
-        PlotPlusListener.startRunnable(this);
-        getServer().getPluginManager().registerEvents(new PlotPlusListener(), this);
-    }
-    
-    @Override
-    public void registerForceFieldEvents() {
-        getServer().getPluginManager().registerEvents(new ForceFieldListener(), this);
-    }
-    
-    @Override
-    public boolean initWorldEdit() {
-        if (getServer().getPluginManager().getPlugin("WorldEdit") != null) {
-            BukkitMain.worldEdit = (WorldEditPlugin) getServer().getPluginManager().getPlugin("WorldEdit");
-            final String version = BukkitMain.worldEdit.getDescription().getVersion();
-            if ((version != null) && version.startsWith("5.")) {
-                log("&cThis version of WorldEdit does not support PlotSquared.");
-                log("&cPlease use WorldEdit 6+ for masking support");
-                log("&c - http://builds.enginehub.org/job/worldedit");
-            } else {
-                getServer().getPluginManager().registerEvents(new WEListener(), this);
-                return true;
-            }
-        }
-        return false;
-    }
-    
-    @Override
-    public EconHandler getEconomyHandler() {
-        try {
-            final BukkitEconHandler econ = new BukkitEconHandler();
-            if (econ.init()) {
-                return econ;
-            }
-        } catch (final Throwable ignored) {
-        }
-        return null;
-    }
-    
-    @Override
-    public PlotQueue initPlotQueue() {
-        try {
-            new SendChunk();
-            MainUtil.canSendChunk = true;
-        } catch (final Throwable e) {
-            e.printStackTrace();
-            MainUtil.canSendChunk = false;
-        }
-        if (PS.get().checkVersion(getServerVersion(), 1, 8, 0)) {
-            try {
-                return new FastQueue_1_8_3();
-            } catch (Throwable e) {
-                e.printStackTrace();
-                try {
-                    return new FastQueue_1_8();
-                } catch (Throwable e2) {
-                    e2.printStackTrace();
-                    return new SlowQueue();
-                }
-            }
-        }
-        try {
-            return new FastQueue_1_7();
-        } catch (Throwable e) {
-            e.printStackTrace();
-            return new SlowQueue();
-        }
-    }
-    
-    @Override
-    public WorldUtil initWorldUtil() {
-        return new BukkitUtil();
-    }
-    
-    @Override
-    public boolean initPlotMeConverter() {
-        TaskManager.runTaskLaterAsync(new Runnable() {
-            @Override
-            public void run() {
-                if (new LikePlotMeConverter("PlotMe").run(new ClassicPlotMeConnector())) {
-                    return;
-                }
-                if (new LikePlotMeConverter("PlotMe").run(new PlotMeConnector_017())) {
-                    return;
-                }
-                if (new LikePlotMeConverter("AthionPlots").run(new ClassicPlotMeConnector())) {
-                    return;
-                }
-            }
-        }, 20);
-        return (Bukkit.getPluginManager().getPlugin("PlotMe") != null) || (Bukkit.getPluginManager().getPlugin("AthionPlots") != null);
-    }
-    
-    @Override
-    public GeneratorWrapper<?> getGenerator(final String world, final String name) {
-        if (name == null) {
-            return null;
-        }
-        final Plugin gen_plugin = Bukkit.getPluginManager().getPlugin(name);
-        if ((gen_plugin != null) && gen_plugin.isEnabled()) {
-            ChunkGenerator gen = gen_plugin.getDefaultWorldGenerator(world, "");
-            if (gen instanceof GeneratorWrapper<?>) {
-                return (GeneratorWrapper<?>) gen;
-            }
-            return new BukkitPlotGenerator(world, gen);
-        } else {
-            return new BukkitPlotGenerator(new HybridGen());
-        }
-    }
-    
-    @Override
-    public HybridUtils initHybridUtils() {
-        return new BukkitHybridUtils();
-    }
-    
-    @Override
-    public SetupUtils initSetupUtils() {
-        return new BukkitSetupUtils();
-    }
-    
-    @Override
-    public UUIDHandlerImplementation initUUIDHandler() {
-        final boolean checkVersion = PS.get().checkVersion(getServerVersion(), 1, 7, 6);
-        UUIDWrapper wrapper;
-        if (Settings.OFFLINE_MODE) {
-            if (Settings.UUID_LOWERCASE) {
-                wrapper = (new LowerOfflineUUIDWrapper());
-            } else {
-                wrapper = (new OfflineUUIDWrapper());
-            }
-            Settings.OFFLINE_MODE = true;
-        } else if (checkVersion) {
-            wrapper = (new DefaultUUIDWrapper());
-            Settings.OFFLINE_MODE = false;
-        } else {
-            if (Settings.UUID_LOWERCASE) {
-                wrapper = (new LowerOfflineUUIDWrapper());
-            } else {
-                wrapper = (new OfflineUUIDWrapper());
-            }
-            Settings.OFFLINE_MODE = true;
-        }
-        if (!checkVersion) {
-            log(C.PREFIX.s() + " &c[WARN] Titles are disabled - please update your version of Bukkit to support this feature.");
-            Settings.TITLES = false;
-            FlagManager.removeFlag(FlagManager.getFlag("titles"));
-        } else {
-            AbstractTitle.TITLE_CLASS = new DefaultTitle();
-            if (wrapper instanceof DefaultUUIDWrapper || wrapper.getClass() == OfflineUUIDWrapper.class && !Bukkit.getOnlineMode()) {
-                Settings.TWIN_MODE_UUID = true;
-            }
-        }
-        if (Settings.OFFLINE_MODE) {
-            log(C.PREFIX.s() + " &6PlotSquared is using Offline Mode UUIDs either because of user preference, or because you are using an old version of Bukkit");
-        } else {
-            log(C.PREFIX.s() + " &6PlotSquared is using online UUIDs");
-        }
-        return Settings.USE_SQLUUIDHANDLER ? new SQLUUIDHandler(wrapper) : new FileUUIDHandler(wrapper);
-    }
-    
-    @Override
-    public ChunkManager initChunkManager() {
-        return new BukkitChunkManager();
-    }
-    
-    @Override
-    public EventUtil initEventUtil() {
-        return new BukkitEventUtil();
-    }
-    
-    @Override
-    public void unregister(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);
-    }
-    
-    @Override
-    public InventoryUtil initInventoryUtil() {
-        return new BukkitInventoryUtil();
-    }
-    
-    @Override
-    public String getServerName() {
-        return Bukkit.getServerName();
-    }
-    
-    @Override
-    public void startMetrics() {
-        try {
-            final Metrics metrics = new Metrics(this);
-            metrics.start();
-            log(C.PREFIX.s() + "&6Metrics enabled.");
-        } catch (IOException e) {
-            log(C.PREFIX.s() + "&cFailed to load up metrics.");
-        }
-    }
-    
-    @Override
-    public void setGenerator(final String worldname) {
-        World world = BukkitUtil.getWorld(worldname);
-        if (world == null) {
-            // create world
-            final ConfigurationSection worldConfig = PS.get().config.getConfigurationSection("worlds." + worldname);
-            String manager = worldConfig.getString("generator.plugin");
-            if (manager == null) {
-                manager = "PlotSquared";
-            }
-            String generator = worldConfig.getString("generator.init");
-            if (generator == null) {
-                generator = manager;
-            }
-            
-            final int type = worldConfig.getInt("generator.type");
-            final int terrain = worldConfig.getInt("generator.terrain");
-            final SetupObject setup = new SetupObject();
-            setup.plotManager = manager;
-            setup.setupGenerator = generator;
-            setup.type = type;
-            setup.terrain = terrain;
-            setup.step = new ConfigurationNode[0];
-            setup.world = worldname;
-            SetupUtils.manager.setupWorld(setup);
-        } else {
-            try {
-                if (!PS.get().hasPlotArea(worldname)) {
-                    SetGenCB.setGenerator(BukkitUtil.getWorld(worldname));
-                }
-            } catch (final Exception e) {
-                log("Failed to reload world: " + world);
-                Bukkit.getServer().unloadWorld(world, false);
-            }
-        }
-        world = Bukkit.getWorld(worldname);
-        final ChunkGenerator gen = world.getGenerator();
-        if (gen instanceof BukkitPlotGenerator) {
-            PS.get().loadWorld(worldname, (BukkitPlotGenerator) gen);
-        } else if (gen != null) {
-            PS.get().loadWorld(worldname, new BukkitPlotGenerator(worldname, gen));
-        } else {
-            if (PS.get().config.contains("worlds." + worldname)) {
-                PS.get().loadWorld(worldname, null);
-            }
-        }
-    }
-    
-    @Override
-    public SchematicHandler initSchematicHandler() {
-        return new BukkitSchematicHandler();
-    }
-    
-    @Override
-    public AbstractTitle initTitleManager() {
-        // Already initialized in UUID handler
-        return AbstractTitle.TITLE_CLASS;
-    }
-    
-    @Override
-    public PlotPlayer wrapPlayer(final Object obj) {
-        if (obj instanceof Player) {
-            return BukkitUtil.getPlayer((Player) obj);
-        } else if (obj instanceof OfflinePlayer) {
-            return BukkitUtil.getPlayer((OfflinePlayer) obj);
-        } else if (obj instanceof String) {
-            return UUIDHandler.getPlayer((String) obj);
-        } else if (obj instanceof UUID) {
-            return UUIDHandler.getPlayer((UUID) obj);
-        }
-        return null;
-    }
-    
-    @Override
-    public String getNMSPackage() {
-        final Server server = Bukkit.getServer();
-        final Class<?> bukkitServerClass = server.getClass();
-        String[] pas = bukkitServerClass.getName().split("\\.");
-        if (pas.length == 5) {
-            return pas[3];
-        }
-        try {
-            final Method getHandle = bukkitServerClass.getDeclaredMethod("getHandle");
-            final Object handle = getHandle.invoke(server);
-            final Class handleServerClass = handle.getClass();
-            pas = handleServerClass.getName().split("\\.");
-            if (pas.length == 5) {
-                return pas[3];
-            }
-        } catch (IllegalAccessException | InvocationTargetException | SecurityException | NoSuchMethodException | IllegalArgumentException e) {
-            e.printStackTrace();
-        }
-        PS.debug("Unknown NMS package: " + StringMan.getString(pas));
-        return "1_8_R3";
-    }
-    
-    @Override
-    public ChatManager<?> initChatManager() {
-        if (Settings.FANCY_CHAT) {
-            return new BukkitChatManager();
-        } else {
-            return new BukkitPlainChatManager();
-        }
-    }
-    
-    @Override
-    public GeneratorWrapper<?> wrapPlotGenerator(IndependentPlotGenerator generator) {
-        return new BukkitPlotGenerator(generator);
-    }
-    
-    @Override
-    public List<String> getPluginIds() {
-        ArrayList<String> names = new ArrayList<>();
-        for (Plugin plugin : Bukkit.getPluginManager().getPlugins()) {
-            names.add(plugin.getName() + ";" + plugin.getDescription().getVersion() + ":" + plugin.isEnabled());
-        }
-        return names;
-    }
-}

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

@@ -1,332 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// PlotSquared - A plot manager and world generator for the Bukkit API                             /
-// Copyright (c) 2014 IntellectualSites/IntellectualCrafters                                       /
-//                                                                                                 /
-// This program is free software; you can redistribute it and/or modify                            /
-// it under the terms of the GNU General Public License as published by                            /
-// the Free Software Foundation; either version 3 of the License, or                               /
-// (at your option) any later version.                                                             /
-//                                                                                                 /
-// This program is distributed in the hope that it will be useful,                                 /
-// but WITHOUT ANY WARRANTY; without even the implied warranty of                                  /
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                   /
-// GNU General Public License for more details.                                                    /
-//                                                                                                 /
-// You should have received a copy of the GNU General Public License                               /
-// along with this program; if not, write to the Free Software Foundation,                         /
-// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA                               /
-//                                                                                                 /
-// You can contact us via: support@intellectualsites.com                                           /
-////////////////////////////////////////////////////////////////////////////////////////////////////
-package com.plotsquared.bukkit.commands;
-
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.commands.CommandCategory;
-import com.intellectualcrafters.plot.commands.RequiredType;
-import com.intellectualcrafters.plot.commands.SubCommand;
-import com.intellectualcrafters.plot.config.C;
-import com.intellectualcrafters.plot.database.AbstractDB;
-import com.intellectualcrafters.plot.database.DBFunc;
-import com.intellectualcrafters.plot.object.OfflinePlotPlayer;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotPlayer;
-import com.intellectualcrafters.plot.object.StringWrapper;
-import com.intellectualcrafters.plot.util.MainUtil;
-import com.intellectualcrafters.plot.util.StringMan;
-import com.intellectualcrafters.plot.util.TaskManager;
-import com.intellectualcrafters.plot.util.UUIDHandler;
-import com.intellectualcrafters.plot.util.WorldUtil;
-import com.intellectualcrafters.plot.uuid.UUIDWrapper;
-import com.plotsquared.bukkit.uuid.DefaultUUIDWrapper;
-import com.plotsquared.bukkit.uuid.LowerOfflineUUIDWrapper;
-import com.plotsquared.bukkit.uuid.OfflineUUIDWrapper;
-import com.plotsquared.general.commands.Argument;
-import com.plotsquared.general.commands.CommandDeclaration;
-
-import java.io.File;
-import java.io.FilenameFilter;
-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() {
-        requiredArguments = new Argument[] { Argument.String };
-    }
-    
-    @Override
-    public boolean onCommand(final PlotPlayer player, final 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 {
-                    final Class<?> clazz = Class.forName(args[0]);
-                    newWrapper = (UUIDWrapper) clazz.newInstance();
-                } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
-                    MainUtil.sendMessage(player, C.COMMAND_SYNTAX, "/plot uuidconvert <lower|offline|online>");
-                    return false;
-                }
-        }
-
-        if (args.length != 2 || !"-o".equals(args[1])) {
-            MainUtil.sendMessage(player, C.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("PlotSquared 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");
-        
-        final HashSet<String> worlds = new HashSet<>();
-        worlds.add(WorldUtil.IMP.getMainWorld());
-        worlds.add("world");
-        final HashSet<UUID> uuids = new HashSet<>();
-        final HashSet<String> names = new HashSet<>();
-        for (final String worldname : worlds) {
-            final File playerdataFolder = new File(worldname + File.separator + "playerdata");
-            String[] dat = playerdataFolder.list(new FilenameFilter() {
-                @Override
-                public boolean accept(final File f, final String s) {
-                    return s.endsWith(".dat");
-                }
-            });
-            if (dat != null)
-                for (final String current : dat) {
-                    final String s = current.replaceAll(".dat$", "");
-                    try {
-                        final UUID uuid = UUID.fromString(s);
-                        uuids.add(uuid);
-                    } catch (final Exception e) {
-                        MainUtil.sendMessage(player, C.PREFIX.s() + "Invalid playerdata: " + current);
-                    }
-                }
-            final File playersFolder = new File(worldname + File.separator + "players");
-            dat = playersFolder.list(new FilenameFilter() {
-                @Override
-                public boolean accept(final File f, final String s) {
-                    return s.endsWith(".dat");
-                }
-            });
-            if (dat != null) {
-                for (final String current : dat) {
-                    names.add(current.replaceAll(".dat$", ""));
-                }
-            }
-        }
-        
-        MainUtil.sendMessage(player, "&7 - Populating map");
-        UUID uuid2;
-        final UUIDWrapper wrapper = new DefaultUUIDWrapper();
-        for (UUID uuid : uuids) {
-            try {
-                final 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 (final Throwable e) {
-                MainUtil.sendMessage(player, C.PREFIX.s() + "&6Invalid playerdata: " + uuid.toString() + ".dat");
-            }
-        }
-        for (final String name : names) {
-            final 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 (final OfflinePlotPlayer op : currentUUIDWrapper.getOfflinePlayers()) {
-                if (op.getLastPlayed() != 0) {
-                    //                    String name = op.getName();
-                    //                    StringWrapper wrap = new StringWrapper(name);
-                    final 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(new Runnable() {
-            @Override
-            public void run() {
-                for (final Entry<UUID, UUID> entry : uCMap.entrySet()) {
-                    final 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)");
-                
-                final File file = new File(PS.get().IMP.getDirectory(), "uuids.txt");
-                if (file.exists()) {
-                    try {
-                        final 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]+[\\|]", "");
-                                final String[] split = line.split("\\|");
-                                final String name = split[0];
-                                if (name.isEmpty() || name.length() > 16 || !StringMan.isAlphanumericUnd(name)) {
-                                    continue;
-                                }
-                                final UUID old = currentUUIDWrapper.getUUID(name);
-                                if (old == null) {
-                                    continue;
-                                }
-                                final UUID now = newWrapper.getUUID(name);
-                                UUIDHandler.add(new StringWrapper(name), now);
-                                uCMap.put(old, now);
-                                uCReverse.put(now, old);
-                            } catch (final Exception e2) {
-                                e2.printStackTrace();
-                            }
-                        }
-                    } catch (final IOException e) {
-                        e.printStackTrace();
-                    }
-                }
-                
-                MainUtil.sendMessage(player, "&7 - Replacing wrapper");
-                UUIDHandler.setUUIDWrapper(newWrapper);
-                
-                MainUtil.sendMessage(player, "&7 - Updating plot objects");
-                
-                for (final Plot plot : PS.get().getPlots()) {
-                    final 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");
-                final AbstractDB database = DBFunc.dbManager;
-                final boolean result = database.deleteTables();
-                
-                MainUtil.sendMessage(player, "&7 - Creating tables");
-                
-                try {
-                    database.createTables();
-                    if (!result) {
-                        MainUtil.sendMessage(player, "&cConversion failed! Attempting recovery");
-                        for (final Plot plot : PS.get().getPlots()) {
-                            final UUID value = uCReverse.get(plot.owner);
-                            if (value != null) {
-                                plot.owner = value;
-                            }
-                        }
-                        database.createPlotsAndData(new ArrayList<>(PS.get().getPlots()), new Runnable() {
-                            @Override
-                            public void run() {
-                                MainUtil.sendMessage(player, "&6Recovery was successful!");
-                            }
-                        });
-                        return;
-                    }
-                } catch (final Exception e) {
-                    e.printStackTrace();
-                    return;
-                }
-                
-                if (newWrapper instanceof OfflineUUIDWrapper) {
-                    PS.get().config.set("UUID.force-lowercase", false);
-                    PS.get().config.set("UUID.offline", true);
-                } else if (newWrapper instanceof DefaultUUIDWrapper) {
-                    PS.get().config.set("UUID.force-lowercase", false);
-                    PS.get().config.set("UUID.offline", false);
-                }
-                try {
-                    PS.get().config.save(PS.get().configFile);
-                } catch (IOException e) {
-                    MainUtil.sendMessage(player, "Could not save configuration. It will need to be manuall set!");
-                }
-                
-                MainUtil.sendMessage(player, "&7 - Populating tables");
-                
-                TaskManager.runTaskAsync(new Runnable() {
-                    @Override
-                    public void run() {
-                        final ArrayList<Plot> plots = new ArrayList<>(PS.get().getPlots());
-                        database.createPlotsAndData(plots, new Runnable() {
-                            @Override
-                            public void run() {
-                                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/plotsquared/bukkit/database/plotme/APlotMeConnector.java

@@ -1,112 +0,0 @@
-package com.plotsquared.bukkit.database.plotme;
-
-import java.sql.Connection;
-import java.sql.SQLException;
-import java.util.Collections;
-import java.util.HashMap;
-
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-
-import com.intellectualcrafters.configuration.file.FileConfiguration;
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.object.Location;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotId;
-
-public abstract class APlotMeConnector {
-    public abstract Connection getPlotMeConnection(final String plugin, final FileConfiguration plotConfig, final String dataFolder);
-    
-    public abstract HashMap<String, HashMap<PlotId, Plot>> getPlotMePlots(final Connection connection) throws SQLException;
-    
-    public abstract boolean accepts(final String version);
-    
-    public String getWorld(final String world) {
-        for (final World newworld : Bukkit.getWorlds()) {
-            if (newworld.getName().equalsIgnoreCase(world)) {
-                return newworld.getName();
-            }
-        }
-        return world;
-    }
-    
-    public boolean isValidConnection(final Connection connection) {
-        return connection != null;
-    }
-    
-    public void copyConfig(final FileConfiguration plotConfig, final String world, final String actualWorldName) {
-        final Integer pathwidth = plotConfig.getInt("worlds." + world + ".PathWidth"); //
-        PS.get().config.set("worlds." + actualWorldName + ".road.width", pathwidth);
-        final Integer plotsize = plotConfig.getInt("worlds." + world + ".PlotSize"); //
-        PS.get().config.set("worlds." + actualWorldName + ".plot.size", plotsize);
-        final String wallblock = plotConfig.getString("worlds." + world + ".WallBlockId"); //
-        PS.get().config.set("worlds." + actualWorldName + ".wall.block", wallblock);
-        final String floor = plotConfig.getString("worlds." + world + ".PlotFloorBlockId"); //
-        PS.get().config.set("worlds." + actualWorldName + ".plot.floor", Collections.singletonList(floor));
-        final String filling = plotConfig.getString("worlds." + world + ".PlotFillingBlockId"); //
-        PS.get().config.set("worlds." + actualWorldName + ".plot.filling", Collections.singletonList(filling));
-        final String road = plotConfig.getString("worlds." + world + ".RoadMainBlockId");
-        PS.get().config.set("worlds." + actualWorldName + ".road.block", road);
-        Integer height = plotConfig.getInt("worlds." + world + ".RoadHeight"); //
-        PS.get().config.set("worlds." + actualWorldName + ".road.height", height);
-    }
-    
-    public Location getPlotTopLocAbs(final int path, final int plot, final PlotId plotid) {
-        final int px = plotid.x;
-        final int pz = plotid.y;
-        final int x = (px * (path + plot)) - ((int) Math.floor(path / 2)) - 1;
-        final int z = (pz * (path + plot)) - ((int) Math.floor(path / 2)) - 1;
-        return new Location(null, x, 256, z);
-    }
-    
-    public Location getPlotBottomLocAbs(final int path, final int plot, final PlotId plotid) {
-        final int px = plotid.x;
-        final int pz = plotid.y;
-        final int x = (px * (path + plot)) - plot - ((int) Math.floor(path / 2)) - 1;
-        final int z = (pz * (path + plot)) - plot - ((int) Math.floor(path / 2)) - 1;
-        return new Location(null, x, 1, z);
-    }
-    
-    public void setMerged(final HashMap<String, HashMap<PlotId, boolean[]>> merges, final String world, final PlotId id, final int direction) {
-        final HashMap<PlotId, boolean[]> plots = merges.get(world);
-        PlotId id2;
-        switch (direction) {
-            case 0: {
-                id2 = new PlotId(id.x, id.y);
-                break;
-            }
-            case 1: {
-                id2 = new PlotId(id.x, id.y);
-                break;
-            }
-            case 2: {
-                id2 = new PlotId(id.x, id.y);
-                break;
-            }
-            case 3: {
-                id2 = new PlotId(id.x, id.y);
-                break;
-            }
-            default: {
-                return;
-            }
-        }
-        boolean[] merge1;
-        boolean[] merge2;
-        if (plots.containsKey(id)) {
-            merge1 = plots.get(id);
-        } else {
-            merge1 = new boolean[] { false, false, false, false };
-        }
-        if (plots.containsKey(id2)) {
-            merge2 = plots.get(id2);
-        } else {
-            merge2 = new boolean[] { false, false, false, false };
-        }
-        merge1[direction] = true;
-        merge2[(direction + 2) % 4] = true;
-        plots.put(id, merge1);
-        plots.put(id2, merge1);
-    }
-    
-}

Bukkit/src/main/java/com/plotsquared/bukkit/database/plotme/ClassicPlotMeConnector.java

@@ -1,267 +0,0 @@
-package com.plotsquared.bukkit.database.plotme;
-
-import com.google.common.base.Charsets;
-import com.intellectualcrafters.configuration.file.FileConfiguration;
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.config.Settings;
-import com.intellectualcrafters.plot.database.DBFunc;
-import com.intellectualcrafters.plot.database.SQLite;
-import com.intellectualcrafters.plot.object.Location;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotArea;
-import com.intellectualcrafters.plot.object.PlotId;
-import com.intellectualcrafters.plot.object.StringWrapper;
-import com.intellectualcrafters.plot.util.UUIDHandler;
-
-import java.io.File;
-import java.nio.ByteBuffer;
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.HashMap;
-import java.util.Map.Entry;
-import java.util.UUID;
-
-public class ClassicPlotMeConnector extends APlotMeConnector {
-    
-    private String plugin;
-    private String prefix;
-    
-    @Override
-    public Connection getPlotMeConnection(final String plugin, final FileConfiguration plotConfig, final String dataFolder) {
-        this.plugin = plugin.toLowerCase();
-        prefix = plotConfig.getString("mySQLprefix");
-        if (prefix == null) {
-            prefix = plugin.toLowerCase();
-        }
-        try {
-            if (plotConfig.getBoolean("usemySQL")) {
-                final String user = plotConfig.getString("mySQLuname");
-                final String password = plotConfig.getString("mySQLpass");
-                final String con = plotConfig.getString("mySQLconn");
-                return DriverManager.getConnection(con, user, password);
-                //                return new MySQL(plotsquared, hostname, port, database, username, password)
-            } else {
-                return new SQLite(dataFolder + File.separator + "plots.db").openConnection();
-            }
-        } catch (SQLException | ClassNotFoundException ignored) {
-        }
-        return null;
-    }
-    
-    @Override
-    public HashMap<String, HashMap<PlotId, Plot>> getPlotMePlots(final Connection connection) throws SQLException {
-        final HashMap<String, Integer> plotWidth = new HashMap<>();
-        final HashMap<String, Integer> roadWidth = new HashMap<>();
-        final HashMap<String, HashMap<PlotId, Plot>> plots = new HashMap<>();
-        final HashMap<String, HashMap<PlotId, boolean[]>> merges = new HashMap<>();
-        PreparedStatement stmt = connection.prepareStatement("SELECT * FROM `" + prefix + "Plots`");
-        ResultSet r = stmt.executeQuery();
-        String column = null;
-        final boolean checkUUID = DBFunc.hasColumn(r, "ownerid");
-        final boolean checkUUID2 = DBFunc.hasColumn(r, "ownerId");
-        if (checkUUID) {
-            column = "ownerid";
-        } else if (checkUUID2) {
-            column = "ownerId";
-        }
-        final boolean merge = !"plotme".equalsIgnoreCase(plugin) && Settings.CONVERT_PLOTME;
-        int missing = 0;
-        while (r.next()) {
-            final PlotId id = new PlotId(r.getInt("idX"), r.getInt("idZ"));
-            final String name = r.getString("owner");
-            final String world = LikePlotMeConverter.getWorld(r.getString("world"));
-            if (!plots.containsKey(world)) {
-                plots.put(world, new HashMap<PlotId, Plot>());
-                if (merge) {
-                    final int plot = PS.get().config.getInt("worlds." + world + ".plot.size");
-                    final int path = PS.get().config.getInt("worlds." + world + ".road.width");
-                    plotWidth.put(world, plot);
-                    roadWidth.put(world, path);
-                    merges.put(world, new HashMap<PlotId, boolean[]>());
-                }
-            }
-            if (merge) {
-                final int tx = r.getInt("topX");
-                final int tz = r.getInt("topZ");
-                final int bx = r.getInt("bottomX") - 1;
-                final int bz = r.getInt("bottomZ") - 1;
-                final int path = roadWidth.get(world);
-                final int plot = plotWidth.get(world);
-                final Location top = getPlotTopLocAbs(path, plot, id);
-                final Location bot = getPlotBottomLocAbs(path, plot, id);
-                if (tx > top.getX()) {
-                    setMerged(merges, world, id, 1);
-                }
-                if (tz > top.getZ()) {
-                    setMerged(merges, world, id, 2);
-                }
-                if (bx < bot.getX()) {
-                    setMerged(merges, world, id, 3);
-                }
-                if (bz > bot.getZ()) {
-                    setMerged(merges, world, id, 0);
-                }
-            }
-            UUID owner = UUIDHandler.getUUID(name, null);
-            if (owner == null) {
-                if ("*".equals(name)) {
-                    owner = DBFunc.everyone;
-                } else {
-                    if (checkUUID || checkUUID2) {
-                        try {
-                            final byte[] bytes = r.getBytes(column);
-                            if (bytes != null) {
-                                try {
-                                    final ByteBuffer bb = ByteBuffer.wrap(bytes);
-                                    final long high = bb.getLong();
-                                    final long low = bb.getLong();
-                                    owner = new UUID(high, low);
-                                } catch (final Exception e) {
-                                    e.printStackTrace();
-                                    owner = UUID.nameUUIDFromBytes(bytes);
-                                }
-                                UUIDHandler.add(new StringWrapper(name), owner);
-                            }
-                        } catch (SQLException e) {
-                            e.printStackTrace();
-                        }
-                    }
-                    if (owner == null) {
-                        if (!name.isEmpty()) {
-                            owner = UUID.nameUUIDFromBytes(("OfflinePlayer:" + name.toLowerCase()).getBytes(Charsets.UTF_8));
-                        }
-                        PS.log("&cCould not identify owner for plot: " + id + " -> '" + name + "'");
-                        missing++;
-                        continue;
-                    }
-                }
-            } else {
-                UUIDHandler.add(new StringWrapper(name), owner);
-            }
-            final Plot plot = new Plot(PlotArea.createGeneric(world), id, owner);
-            plots.get(world).put(id, plot);
-        }
-        if (missing > 0) {
-            PS.log("&cSome names could not be identified:");
-            PS.log("&7 - Empty quotes mean PlotMe just stored an unowned plot in the database");
-            PS.log("&7 - Names you have never seen before could be from people mistyping commands");
-            PS.log("&7 - Converting from a non-uuid version of PlotMe can't identify owners if the playerdata files are deleted (these plots will remain unknown until the player connects)");
-        }
-        
-        for (final Entry<String, HashMap<PlotId, boolean[]>> entry : merges.entrySet()) {
-            final String world = entry.getKey();
-            for (final Entry<PlotId, boolean[]> entry2 : entry.getValue().entrySet()) {
-                final HashMap<PlotId, Plot> newplots = plots.get(world);
-                final Plot plot = newplots.get(entry2.getKey());
-                if (plot != null) {
-                    plot.setMerged(entry2.getValue());
-                }
-            }
-        }
-        
-        r.close();
-        stmt.close();
-
-        try {
-
-            PS.log(" - " + prefix + "Denied");
-            stmt = connection.prepareStatement("SELECT * FROM `" + prefix + "Denied`");
-            r = stmt.executeQuery();
-
-            while (r.next()) {
-                final PlotId id = new PlotId(r.getInt("idX"), r.getInt("idZ"));
-                final String name = r.getString("player");
-                final String world = LikePlotMeConverter.getWorld(r.getString("world"));
-                UUID denied = UUIDHandler.getUUID(name, null);
-                if (denied == null) {
-                    if ("*".equals(name)) {
-                        denied = DBFunc.everyone;
-                    } else {
-                        if (DBFunc.hasColumn(r, "playerid")) {
-                            try {
-                                final byte[] bytes = r.getBytes("playerid");
-                                if (bytes != null) {
-                                    try {
-                                        final ByteBuffer bb = ByteBuffer.wrap(bytes);
-                                        final long high = bb.getLong();
-                                        final long low = bb.getLong();
-                                        denied = new UUID(high, low);
-                                    } catch (final Exception e) {
-                                        e.printStackTrace();
-                                        denied = UUID.nameUUIDFromBytes(bytes);
-                                    }
-                                    UUIDHandler.add(new StringWrapper(name), denied);
-                                }
-                            } catch (SQLException e) {
-                                e.printStackTrace();
-                            }
-                        }
-                    }
-                    if (denied == null) {
-                        PS.log("&6Could not identify denied for plot: " + id);
-                        continue;
-                    }
-                }
-                if (plots.get(world).containsKey(id)) {
-                    plots.get(world).get(id).getDenied().add(denied);
-                }
-            }
-
-            stmt = connection.prepareStatement("SELECT * FROM `" + plugin + "Allowed`");
-            r = stmt.executeQuery();
-
-            while (r.next()) {
-                final PlotId id = new PlotId(r.getInt("idX"), r.getInt("idZ"));
-                final String name = r.getString("player");
-                final String world = LikePlotMeConverter.getWorld(r.getString("world"));
-                UUID helper = UUIDHandler.getUUID(name, null);
-                if (helper == null) {
-                    if ("*".equals(name)) {
-                        helper = DBFunc.everyone;
-                    } else {
-                        if (DBFunc.hasColumn(r, "playerid")) {
-                            try {
-                                final byte[] bytes = r.getBytes("playerid");
-                                if (bytes != null) {
-                                    try {
-                                        final ByteBuffer bb = ByteBuffer.wrap(bytes);
-                                        final long high = bb.getLong();
-                                        final long low = bb.getLong();
-                                        helper = new UUID(high, low);
-                                    } catch (final Exception e) {
-                                        e.printStackTrace();
-                                        helper = UUID.nameUUIDFromBytes(bytes);
-                                    }
-                                    UUIDHandler.add(new StringWrapper(name), helper);
-                                }
-                            } catch (SQLException e) {
-                                e.printStackTrace();
-                            }
-                        }
-                    }
-                    if (helper == null) {
-                        PS.log("&6Could not identify helper for plot: " + id);
-                        continue;
-                    }
-                }
-                if (plots.get(world).containsKey(id)) {
-                    plots.get(world).get(id).getTrusted().add(helper);
-                }
-            }
-
-            r.close();
-            stmt.close();
-
-        } catch (SQLException e) {
-        }
-        return plots;
-    }
-    
-    @Override
-    public boolean accepts(final String version) {
-        return version == null || PS.get().canUpdate(version, "0.17.0") || PS.get().canUpdate("0.999.999", version);
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/database/plotme/LikePlotMeConverter.java

@@ -1,406 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// PlotSquared - A plot manager and world generator for the Bukkit API                             /
-// Copyright (c) 2014 IntellectualSites/IntellectualCrafters                                       /
-//                                                                                                 /
-// This program is free software; you can redistribute it and/or modify                            /
-// it under the terms of the GNU General Public License as published by                            /
-// the Free Software Foundation; either version 3 of the License, or                               /
-// (at your option) any later version.                                                             /
-//                                                                                                 /
-// This program is distributed in the hope that it will be useful,                                 /
-// but WITHOUT ANY WARRANTY; without even the implied warranty of                                  /
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                   /
-// GNU General Public License for more details.                                                    /
-//                                                                                                 /
-// You should have received a copy of the GNU General Public License                               /
-// along with this program; if not, write to the Free Software Foundation,                         /
-// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA                               /
-//                                                                                                 /
-// You can contact us via: support@intellectualsites.com                                           /
-////////////////////////////////////////////////////////////////////////////////////////////////////
-package com.plotsquared.bukkit.database.plotme;
-
-import com.intellectualcrafters.configuration.MemorySection;
-import com.intellectualcrafters.configuration.file.FileConfiguration;
-import com.intellectualcrafters.configuration.file.YamlConfiguration;
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.config.Settings;
-import com.intellectualcrafters.plot.database.DBFunc;
-import com.intellectualcrafters.plot.generator.HybridGen;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotArea;
-import com.intellectualcrafters.plot.object.PlotId;
-import com.intellectualcrafters.plot.util.TaskManager;
-import com.plotsquared.bukkit.generator.BukkitPlotGenerator;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.bukkit.WorldCreator;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.sql.Connection;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map.Entry;
-import java.util.Set;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-/**
- * Created 2014-08-17 for PlotSquared
- *
-
-
- */
-public class LikePlotMeConverter {
-    private final String plugin;
-    
-    /**
-     * Constructor
-     *
-     * @param plugin Plugin Used to run the converter
-     */
-    public LikePlotMeConverter(final String plugin) {
-        this.plugin = plugin;
-    }
-    
-    public static String getWorld(final String world) {
-        for (final World newworld : Bukkit.getWorlds()) {
-            if (newworld.getName().equalsIgnoreCase(world)) {
-                return newworld.getName();
-            }
-        }
-        return world;
-    }
-    
-    private void sendMessage(final String message) {
-        PS.debug("&3PlotMe&8->&3PlotSquared&8: &7" + message);
-    }
-    
-    public String getPlotMePath() {
-        return new File(".").getAbsolutePath() + File.separator + "plugins" + File.separator + plugin + File.separator;
-    }
-    
-    public String getAthionPlotsPath() {
-        return new File(".").getAbsolutePath() + File.separator + "plugins" + File.separator + plugin + File.separator;
-    }
-    
-    public FileConfiguration getPlotMeConfig(final String dataFolder) {
-        final File plotMeFile = new File(dataFolder + "config.yml");
-        if (!plotMeFile.exists()) {
-            return null;
-        }
-        return YamlConfiguration.loadConfiguration(plotMeFile);
-    }
-    
-    public Set<String> getPlotMeWorlds(final FileConfiguration plotConfig) {
-        return plotConfig.getConfigurationSection("worlds").getKeys(false);
-    }
-    
-    public void mergeWorldYml(final String plugin, FileConfiguration plotConfig) {
-        try {
-            File genConfig = new File("plugins" + File.separator + plugin + File.separator + "PlotMe-DefaultGenerator" + File.separator + "config.yml");
-            if (genConfig.exists()) {
-                YamlConfiguration yml = YamlConfiguration.loadConfiguration(genConfig);
-                for (String key : yml.getKeys(true)) {
-                    if (!plotConfig.contains(key)) {
-                        Object value = yml.get(key);
-                        if (!(value instanceof MemorySection)) {
-                            plotConfig.set(key, value);
-                        }
-                    }
-                }
-            }
-        }
-        catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-    
-    public void updateWorldYml(final String plugin, final String location) {
-        try {
-            final Path path = Paths.get(location);
-            final File file = new File(location);
-            if (!file.exists()) {
-                return;
-            }
-            final Charset charset = StandardCharsets.UTF_8;
-            String content = new String(Files.readAllBytes(path), charset);
-            content = content.replaceAll("PlotMe-DefaultGenerator", "PlotSquared");
-            content = content.replaceAll(plugin, "PlotSquared");
-            Files.write(path, content.getBytes(charset));
-        } catch (IOException e) {
-        }
-    }
-    
-    public boolean run(final APlotMeConnector connector) {
-        try {
-            final String dataFolder = getPlotMePath();
-            final FileConfiguration plotConfig = getPlotMeConfig(dataFolder);
-            if (plotConfig == null) {
-                return false;
-            }
-            
-            String version = plotConfig.getString("Version");
-            if (version == null) {
-                version = plotConfig.getString("version");
-            }
-            if (!connector.accepts(version)) {
-                return false;
-            }
-            
-            PS.debug("&3Using connector: " + connector.getClass().getCanonicalName());
-            
-            final Connection connection = connector.getPlotMeConnection(plugin, plotConfig, dataFolder);
-            
-            if (!connector.isValidConnection(connection)) {
-                sendMessage("Cannot connect to PlotMe DB. Conversion process will not continue");
-                return false;
-            }
-            
-            sendMessage(plugin + " conversion has started. To disable this, please set 'plotme-convert.enabled' to false in the 'settings.yml'");
-            
-            mergeWorldYml(plugin, plotConfig);
-            
-            sendMessage("Connecting to " + plugin + " DB");
-            
-            int plotCount = 0;
-            final ArrayList<Plot> createdPlots = new ArrayList<>();
-            
-            sendMessage("Collecting plot data");
-            
-            final String dbPrefix = plugin.toLowerCase();
-            sendMessage(" - " + dbPrefix + "Plots");
-            final Set<String> worlds = getPlotMeWorlds(plotConfig);
-            
-            if (Settings.CONVERT_PLOTME) {
-                sendMessage("Updating bukkit.yml");
-                updateWorldYml(plugin, "bukkit.yml");
-                updateWorldYml(plugin, "plugins/Multiverse-Core/worlds.yml");
-                for (final String world : plotConfig.getConfigurationSection("worlds").getKeys(false)) {
-                    sendMessage("Copying config for: " + world);
-                    try {
-                        final String actualWorldName = getWorld(world);
-                        connector.copyConfig(plotConfig, world, actualWorldName);
-                        PS.get().config.save(PS.get().configFile);
-                    } catch (final Exception e) {
-                        e.printStackTrace();
-                        sendMessage("&c-- &lFailed to save configuration for world '" + world + "'\nThis will need to be done using the setup command, or manually");
-                    }
-                }
-            }
-            final HashMap<String, HashMap<PlotId, Plot>> plots = connector.getPlotMePlots(connection);
-            for (final Entry<String, HashMap<PlotId, Plot>> entry : plots.entrySet()) {
-                plotCount += entry.getValue().size();
-            }
-            if (!Settings.CONVERT_PLOTME) {
-                return false;
-            }
-            
-            sendMessage(" - " + dbPrefix + "Allowed");
-            
-            sendMessage("Collected " + plotCount + " plots from PlotMe");
-            final File PLOTME_DG_FILE = new File(dataFolder + File.separator + "PlotMe-DefaultGenerator" + File.separator + "config.yml");
-            if (PLOTME_DG_FILE.exists()) {
-                final YamlConfiguration PLOTME_DG_YML = YamlConfiguration.loadConfiguration(PLOTME_DG_FILE);
-                try {
-                    for (final String world : plots.keySet()) {
-                        final String actualWorldName = getWorld(world);
-                        final String plotMeWorldName = world.toLowerCase();
-                        Integer pathwidth = PLOTME_DG_YML.getInt("worlds." + plotMeWorldName + ".PathWidth"); //
-                        /*
-                         * TODO: dead code
-                         * 
-                        if (pathwidth == null) {
-                            pathwidth = 7;
-                        }
-                        */
-                        PS.get().config.set("worlds." + world + ".road.width", pathwidth);
-
-                        Integer pathheight = PLOTME_DG_YML.getInt("worlds." + plotMeWorldName + ".RoadHeight"); //
-                        if (pathheight == 0) {
-                            pathheight = 64;
-                        }
-                        PS.get().config.set("worlds." + world + ".road.height", pathheight);
-                        PS.get().config.set("worlds." + world + ".wall.height", pathheight);
-                        PS.get().config.set("worlds." + world + ".plot.height", pathheight);
-                        Integer plotsize = PLOTME_DG_YML.getInt("worlds." + plotMeWorldName + ".PlotSize"); //
-                        if (plotsize == 0) {
-                            plotsize = 32;
-                        }
-                        PS.get().config.set("worlds." + world + ".plot.size", plotsize);
-                        String wallblock = PLOTME_DG_YML.getString("worlds." + plotMeWorldName + ".WallBlock"); //
-                        if (wallblock == null) {
-                            wallblock = "44";
-                        }
-                        PS.get().config.set("worlds." + world + ".wall.block", wallblock);
-                        String floor = PLOTME_DG_YML.getString("worlds." + plotMeWorldName + ".PlotFloorBlock"); //
-                        if (floor == null) {
-                            floor = "2";
-                        }
-                        PS.get().config.set("worlds." + world + ".plot.floor", Collections.singletonList(floor));
-                        String filling = PLOTME_DG_YML.getString("worlds." + plotMeWorldName + ".FillBlock"); //
-                        if (filling == null) {
-                            filling = "3";
-                        }
-                        PS.get().config.set("worlds." + world + ".plot.filling", Collections.singletonList(filling));
-                        String road = PLOTME_DG_YML.getString("worlds." + plotMeWorldName + ".RoadMainBlock");
-                        if (road == null) {
-                            road = "5";
-                        }
-                        PS.get().config.set("worlds." + world + ".road.block", road);
-                        Integer height = PLOTME_DG_YML.getInt("worlds." + plotMeWorldName + ".RoadHeight"); //
-                        if (height == 0) {
-                            height = PLOTME_DG_YML.getInt("worlds." + plotMeWorldName + ".GroundHeight"); //
-                            if (height == 0) {
-                                height = 64;
-                            }
-                        }
-                        PS.get().config.set("worlds." + actualWorldName + ".road.height", height);
-                        PS.get().config.set("worlds." + actualWorldName + ".plot.height", height);
-                        PS.get().config.set("worlds." + actualWorldName + ".wall.height", height);
-                        PS.get().config.save(PS.get().configFile);
-                    }
-                } catch (IOException e) {
-                }
-            }
-            for (Entry<String, HashMap<PlotId, Plot>> entry : plots.entrySet()) {
-                String world = entry.getKey();
-                PlotArea area = PS.get().getPlotArea(world, null);
-                int duplicate = 0;
-                if (area != null) {
-                    for (Entry<PlotId, Plot> entry2 : entry.getValue().entrySet()) {
-                        if (area.getOwnedPlotAbs(entry2.getKey()) != null) {
-                            duplicate++;
-                        } else {
-                            createdPlots.add(entry2.getValue());
-                        }
-                    }
-                    if (duplicate > 0) {
-                        PS.debug("&c[WARNING] Found " + duplicate + " duplicate plots already in DB for world: '" + world + "'. Have you run the converter already?");
-                    }
-                } else {
-                    if (PS.get().plots_tmp != null) {
-                        HashMap<PlotId, Plot> map = PS.get().plots_tmp.get(world);
-                        if (map != null) {
-                            for (Entry<PlotId, Plot> entry2 : entry.getValue().entrySet()) {
-                                if (map.containsKey(entry2.getKey())) {
-                                    duplicate++;
-                                } else {
-                                    createdPlots.add(entry2.getValue());
-                                }
-                            }
-                            if (duplicate > 0) {
-                                PS.debug("&c[WARNING] Found " + duplicate + " duplicate plots already in DB for world: '" + world + "'. Have you run the converter already?");
-                            }
-                            continue;
-                        }
-                    }
-                    createdPlots.addAll(entry.getValue().values());
-                }
-            }
-            sendMessage("Creating plot DB");
-            Thread.sleep(1000);
-            final AtomicBoolean done = new AtomicBoolean(false);
-            DBFunc.createPlotsAndData(createdPlots, new Runnable() {
-                @Override
-                public void run() {
-                    if (done.get()) {
-                        done();
-                        sendMessage("&aDatabase conversion is now complete!");
-                        PS.debug("&c - Stop the server");
-                        PS.debug("&c - Disable 'plotme-convert.enabled' and 'plotme-convert.cache-uuids' in the settings.yml");
-                        PS.debug("&c - Correct any generator settings that haven't copied to 'settings.yml' properly");
-                        PS.debug("&c - Start the server");
-                        PS.get().setPlots(DBFunc.getPlots());
-                    } else {
-                        sendMessage("&cPlease wait until database conversion is complete. You will be notified with instructions when this happens!");
-                        done.set(true);
-                    }
-                }
-            });
-            sendMessage("Saving configuration...");
-            try {
-                PS.get().config.save(PS.get().configFile);
-            } catch (final IOException e) {
-                sendMessage(" - &cFailed to save configuration.");
-            }
-            TaskManager.runTask(new Runnable() {
-                @Override
-                public void run() {
-                    try {
-                        boolean MV = false;
-                        boolean MW = false;
-                        if ((Bukkit.getPluginManager().getPlugin("Multiverse-Core") != null) && Bukkit.getPluginManager().getPlugin("Multiverse-Core").isEnabled()) {
-                            MV = true;
-                        } else if ((Bukkit.getPluginManager().getPlugin("MultiWorld") != null) && Bukkit.getPluginManager().getPlugin("MultiWorld").isEnabled()) {
-                            MW = true;
-                        }
-                        for (final String worldname : worlds) {
-                            final World world = Bukkit.getWorld(getWorld(worldname));
-                            if (world == null) {
-                                sendMessage("&cInvalid world in PlotMe configuration: " + worldname);
-                            }
-                            final String actualWorldName = world.getName();
-                            sendMessage("Reloading generator for world: '" + actualWorldName + "'...");
-                            PS.get().removePlotAreas(actualWorldName);
-                            if (MV) {
-                                // unload world with MV
-                                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), "mv unload " + actualWorldName);
-                                try {
-                                    Thread.sleep(1000);
-                                } catch (final InterruptedException ex) {
-                                    Thread.currentThread().interrupt();
-                                }
-                                // load world with MV
-                                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), "mv import " + actualWorldName + " normal -g PlotSquared");
-                            } else if (MW) {
-                                // unload world with MW
-                                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), "mw unload " + actualWorldName);
-                                try {
-                                    Thread.sleep(1000);
-                                } catch (final InterruptedException ex) {
-                                    Thread.currentThread().interrupt();
-                                }
-                                // load world with MW
-                                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), "mw create " + actualWorldName + " plugin:PlotSquared");
-                            } else {
-                                // Load using Bukkit API
-                                // - User must set generator manually
-                                Bukkit.getServer().unloadWorld(world, true);
-                                final World myworld = WorldCreator.name(actualWorldName).generator(new BukkitPlotGenerator(new HybridGen())).createWorld();
-                                myworld.save();
-                            }
-                        }
-                    } catch (final Exception e) {
-                        e.printStackTrace();
-                    }
-                    if (done.get()) {
-                        done();
-                        sendMessage("&aDatabase conversion is now complete!");
-                        PS.debug("&c - Stop the server");
-                        PS.debug("&c - Disable 'plotme-convert.enabled' and 'plotme-convert.cache-uuids' in the settings.yml");
-                        PS.debug("&c - Correct any generator settings that haven't copied to 'settings.yml' properly");
-                        PS.debug("&c - Start the server");
-                    } else {
-                        sendMessage("&cPlease wait until database conversion is complete. You will be notified with instructions when this happens!");
-                        done.set(true);
-                    }
-                }
-            });
-        } catch (final Exception e) {
-            e.printStackTrace();
-            PS.debug("&/end/");
-        }
-        return true;
-    }
-    
-    public void done() {
-        PS.get().setPlots(DBFunc.getPlots());
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/database/plotme/PlotMeConnector_017.java

@@ -1,200 +0,0 @@
-package com.plotsquared.bukkit.database.plotme;
-
-import com.intellectualcrafters.configuration.file.FileConfiguration;
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.config.Settings;
-import com.intellectualcrafters.plot.database.DBFunc;
-import com.intellectualcrafters.plot.database.SQLite;
-import com.intellectualcrafters.plot.object.Location;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotArea;
-import com.intellectualcrafters.plot.object.PlotId;
-import com.intellectualcrafters.plot.object.StringWrapper;
-import com.intellectualcrafters.plot.util.UUIDHandler;
-
-import java.io.File;
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.HashMap;
-import java.util.Map.Entry;
-import java.util.UUID;
-
-public class PlotMeConnector_017 extends APlotMeConnector {
-    private String plugin;
-
-    @Override
-    public Connection getPlotMeConnection(final String plugin, final FileConfiguration plotConfig, final String dataFolder) {
-        this.plugin = plugin.toLowerCase();
-        try {
-            if (plotConfig.getBoolean("usemySQL")) {
-                final String user = plotConfig.getString("mySQLuname");
-                final String password = plotConfig.getString("mySQLpass");
-                final String con = plotConfig.getString("mySQLconn");
-                return DriverManager.getConnection(con, user, password);
-            } else {
-                final File file = new File(dataFolder + File.separator + "plotmecore.db");
-                if (file.exists()) {
-                    return new SQLite(dataFolder + File.separator + "plotmecore.db").openConnection();
-                }
-                return new SQLite(dataFolder + File.separator + "plots.db").openConnection();
-            }
-        } catch (SQLException | ClassNotFoundException e) {}
-        return null;
-    }
-    
-    @Override
-    public HashMap<String, HashMap<PlotId, Plot>> getPlotMePlots(final Connection connection) throws SQLException {
-        ResultSet r;
-        PreparedStatement stmt;
-        final HashMap<String, Integer> plotWidth = new HashMap<>();
-        final HashMap<String, Integer> roadWidth = new HashMap<>();
-        final HashMap<Integer, Plot> plots = new HashMap<>();
-        final HashMap<String, HashMap<PlotId, boolean[]>> merges = new HashMap<>();
-        try {
-            stmt = connection.prepareStatement("SELECT * FROM `" + plugin + "core_plots`");
-            r = stmt.executeQuery();
-        } catch (SQLException e) {
-            PS.debug("========= Table does not exist =========");
-            e.printStackTrace();
-            PS.debug("=======================================");
-            PS.debug("&8 - &7The database does not match the version specified in the PlotMe config");
-            PS.debug("&8 - &7Please correct this, or if you are unsure, the most common is 0.16.3");
-            return null;
-        }
-        final boolean checkUUID = DBFunc.hasColumn(r, "ownerID");
-        final boolean merge = !plugin.equals("plotme") && Settings.CONVERT_PLOTME;
-        while (r.next()) {
-            final int key = r.getInt("plot_id");
-            final PlotId id = new PlotId(r.getInt("plotX"), r.getInt("plotZ"));
-            final String name = r.getString("owner");
-            final String world = LikePlotMeConverter.getWorld(r.getString("world"));
-            if (!plots.containsKey(world)) {
-                if (merge) {
-                    final int plot = PS.get().config.getInt("worlds." + world + ".plot.size");
-                    final int path = PS.get().config.getInt("worlds." + world + ".road.width");
-                    plotWidth.put(world, plot);
-                    roadWidth.put(world, path);
-                    merges.put(world, new HashMap<PlotId, boolean[]>());
-                }
-            }
-            if (merge) {
-                final int tx = r.getInt("topX");
-                final int tz = r.getInt("topZ");
-                final int bx = r.getInt("bottomX") - 1;
-                final int bz = r.getInt("bottomZ") - 1;
-                final int path = roadWidth.get(world);
-                final int plot = plotWidth.get(world);
-                final Location top = getPlotTopLocAbs(path, plot, id);
-                final Location bot = getPlotBottomLocAbs(path, plot, id);
-                if (tx > top.getX()) {
-                    setMerged(merges, world, id, 1);
-                }
-                if (tz > top.getZ()) {
-                    setMerged(merges, world, id, 2);
-                }
-                if (bx < bot.getX()) {
-                    setMerged(merges, world, id, 3);
-                }
-                if (bz > bot.getZ()) {
-                    setMerged(merges, world, id, 0);
-                }
-            }
-            UUID owner = UUIDHandler.getUUID(name, null);
-            if (owner == null) {
-                if (name.equals("*")) {
-                    owner = DBFunc.everyone;
-                } else {
-                    if (checkUUID) {
-                        try {
-                            final byte[] bytes = r.getBytes("ownerid");
-                            if (bytes != null) {
-                                owner = UUID.nameUUIDFromBytes(bytes);
-                                UUIDHandler.add(new StringWrapper(name), owner);
-                            }
-                        } catch (final Exception e) {
-                            e.printStackTrace();
-                        }
-                    }
-                    if (owner == null) {
-                        PS.log("&cCould not identify owner for plot: " + id + " -> '" + name + "'");
-                        continue;
-                    }
-                }
-            } else {
-                UUIDHandler.add(new StringWrapper(name), owner);
-            }
-            final Plot plot = new Plot(PlotArea.createGeneric(world), id, owner);
-            plots.put(key, plot);
-        }
-        for (final Entry<Integer, Plot> entry : plots.entrySet()) {
-            final Plot plot = entry.getValue();
-            final HashMap<PlotId, boolean[]> mergeMap = merges.get(plot.getArea().worldname);
-            if (mergeMap != null) {
-                if (mergeMap.containsKey(plot.getId())) {
-                    plot.setMerged(mergeMap.get(plot.getId()));
-                }
-            }
-        }
-        r.close();
-        stmt.close();
-        try {
-            PS.log(" - " + plugin + "core_denied");
-            stmt = connection.prepareStatement("SELECT * FROM `" + plugin + "core_denied`");
-            r = stmt.executeQuery();
-
-            while (r.next()) {
-                final int key = r.getInt("plot_id");
-                final Plot plot = plots.get(key);
-                if (plot == null) {
-                    PS.log("&6Denied (" + key + ") references deleted plot; ignoring entry.");
-                    continue;
-                }
-                final UUID denied = UUID.fromString(r.getString("player"));
-                plot.getDenied().add(denied);
-            }
-
-            PS.log(" - " + plugin + "core_allowed");
-            stmt = connection.prepareStatement("SELECT * FROM `" + plugin + "core_allowed`");
-            r = stmt.executeQuery();
-
-            while (r.next()) {
-                final int key = r.getInt("plot_id");
-                final Plot plot = plots.get(key);
-                if (plot == null) {
-                    PS.log("&6Allowed (" + key + ") references deleted plot; ignoring entry.");
-                    continue;
-                }
-                final UUID allowed = UUID.fromString(r.getString("player"));
-                plot.getTrusted().add(allowed);
-            }
-            r.close();
-            stmt.close();
-
-        } catch (SQLException e) {
-            e.printStackTrace();
-        }
-        final HashMap<String, HashMap<PlotId, Plot>> processed = new HashMap<>();
-        
-        for (final Entry<Integer, Plot> entry : plots.entrySet()) {
-            final Plot plot = entry.getValue();
-            HashMap<PlotId, Plot> map = processed.get(plot.getArea().worldname);
-            if (map == null) {
-                map = new HashMap<>();
-                processed.put(plot.getArea().worldname, map);
-            }
-            map.put(plot.getId(), plot);
-        }
-        return processed;
-    }
-    
-    @Override
-    public boolean accepts(final String version) {
-        if (version == null) {
-            return false;
-        }
-        return !PS.get().canUpdate(version, "0.17");
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/events/ClusterFlagRemoveEvent.java

@@ -1,89 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// PlotSquared - A plot manager and world generator for the Bukkit API                             /
-// Copyright (c) 2014 IntellectualSites/IntellectualCrafters                                       /
-//                                                                                                 /
-// This program is free software; you can redistribute it and/or modify                            /
-// it under the terms of the GNU General Public License as published by                            /
-// the Free Software Foundation; either version 3 of the License, or                               /
-// (at your option) any later version.                                                             /
-//                                                                                                 /
-// This program is distributed in the hope that it will be useful,                                 /
-// but WITHOUT ANY WARRANTY; without even the implied warranty of                                  /
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                   /
-// GNU General Public License for more details.                                                    /
-//                                                                                                 /
-// You should have received a copy of the GNU General Public License                               /
-// along with this program; if not, write to the Free Software Foundation,                         /
-// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA                               /
-//                                                                                                 /
-// You can contact us via: support@intellectualsites.com                                           /
-////////////////////////////////////////////////////////////////////////////////////////////////////
-package com.plotsquared.bukkit.events;
-
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-
-import com.intellectualcrafters.plot.flag.Flag;
-import com.intellectualcrafters.plot.object.PlotCluster;
-
-/**
- * Called when a flag is removed from a plot
- *
-
-
- */
-public class ClusterFlagRemoveEvent extends Event implements Cancellable {
-    private static HandlerList handlers = new HandlerList();
-    private final PlotCluster cluster;
-    private final Flag flag;
-    private boolean cancelled;
-    
-    /**
-     * PlotFlagRemoveEvent: Called when a flag is removed from a plot
-     *
-     * @param flag Flag that was removed
-     * @param cluster PlotCluster from which the flag was removed
-     */
-    public ClusterFlagRemoveEvent(final Flag flag, final PlotCluster cluster) {
-        this.cluster = cluster;
-        this.flag = flag;
-    }
-    
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-    
-    /**
-     * Get the cluster involved
-     *
-     * @return PlotCluster
-     */
-    public PlotCluster getCluster() {
-        return cluster;
-    }
-    
-    /**
-     * Get the flag involved
-     *
-     * @return Flag
-     */
-    public Flag getFlag() {
-        return flag;
-    }
-    
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-    
-    @Override
-    public boolean isCancelled() {
-        return cancelled;
-    }
-    
-    @Override
-    public void setCancelled(final boolean b) {
-        cancelled = b;
-    }
-}

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

@@ -1,84 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// PlotSquared - A plot manager and world generator for the Bukkit API                             /
-// Copyright (c) 2014 IntellectualSites/IntellectualCrafters                                       /
-//                                                                                                 /
-// This program is free software; you can redistribute it and/or modify                            /
-// it under the terms of the GNU General Public License as published by                            /
-// the Free Software Foundation; either version 3 of the License, or                               /
-// (at your option) any later version.                                                             /
-//                                                                                                 /
-// This program is distributed in the hope that it will be useful,                                 /
-// but WITHOUT ANY WARRANTY; without even the implied warranty of                                  /
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                   /
-// GNU General Public License for more details.                                                    /
-//                                                                                                 /
-// You should have received a copy of the GNU General Public License                               /
-// along with this program; if not, write to the Free Software Foundation,                         /
-// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA                               /
-//                                                                                                 /
-// You can contact us via: support@intellectualsites.com                                           /
-////////////////////////////////////////////////////////////////////////////////////////////////////
-package com.plotsquared.bukkit.events;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.player.PlayerEvent;
-
-import com.intellectualcrafters.plot.object.Plot;
-
-/**
-
-
- */
-public class PlayerClaimPlotEvent extends PlayerEvent implements Cancellable {
-    private static 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(final Player player, final Plot plot, final 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 plot;
-    }
-    
-    /**
-     * @return true if it was an automated claim, else false
-     */
-    public boolean wasAuto() {
-        return auto;
-    }
-    
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-    
-    @Override
-    public boolean isCancelled() {
-        return cancelled;
-    }
-    
-    @Override
-    public void setCancelled(final boolean b) {
-        cancelled = b;

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

@@ -1,63 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// PlotSquared - A plot manager and world generator for the Bukkit API                             /
-// Copyright (c) 2014 IntellectualSites/IntellectualCrafters                                       /
-//                                                                                                 /
-// This program is free software; you can redistribute it and/or modify                            /
-// it under the terms of the GNU General Public License as published by                            /
-// the Free Software Foundation; either version 3 of the License, or                               /
-// (at your option) any later version.                                                             /
-//                                                                                                 /
-// This program is distributed in the hope that it will be useful,                                 /
-// but WITHOUT ANY WARRANTY; without even the implied warranty of                                  /
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                   /
-// GNU General Public License for more details.                                                    /
-//                                                                                                 /
-// You should have received a copy of the GNU General Public License                               /
-// along with this program; if not, write to the Free Software Foundation,                         /
-// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA                               /
-//                                                                                                 /
-// You can contact us via: support@intellectualsites.com                                           /
-////////////////////////////////////////////////////////////////////////////////////////////////////
-package com.plotsquared.bukkit.events;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.player.PlayerEvent;
-
-import com.intellectualcrafters.plot.object.Plot;
-
-/**
-
-
- */
-public class PlayerEnterPlotEvent extends PlayerEvent {
-    private static HandlerList handlers = new HandlerList();
-    private final Plot plot;
-    
-    /**
-     * PlayerEnterPlotEvent: Called when a player leaves a plot
-     *
-     * @param player Player that entered the plot
-     * @param plot   Plot that was entered
-     */
-    public PlayerEnterPlotEvent(final Player player, final Plot plot) {
-        super(player);
-        this.plot = plot;
-    }
-    
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-    
-    /**
-     * Get the plot involved
-     *
-     * @return Plot
-     */
-    public Plot getPlot() {
-        return plot;
-    }
-    
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;

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

@@ -1,64 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// PlotSquared - A plot manager and world generator for the Bukkit API                             /
-// Copyright (c) 2014 IntellectualSites/IntellectualCrafters                                       /
-//                                                                                                 /
-// This program is free software; you can redistribute it and/or modify                            /
-// it under the terms of the GNU General Public License as published by                            /
-// the Free Software Foundation; either version 3 of the License, or                               /
-// (at your option) any later version.                                                             /
-//                                                                                                 /
-// This program is distributed in the hope that it will be useful,                                 /
-// but WITHOUT ANY WARRANTY; without even the implied warranty of                                  /
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                   /
-// GNU General Public License for more details.                                                    /
-//                                                                                                 /
-// You should have received a copy of the GNU General Public License                               /
-// along with this program; if not, write to the Free Software Foundation,                         /
-// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA                               /
-//                                                                                                 /
-// You can contact us via: support@intellectualsites.com                                           /
-////////////////////////////////////////////////////////////////////////////////////////////////////
-package com.plotsquared.bukkit.events;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.player.PlayerEvent;
-
-import com.intellectualcrafters.plot.object.Plot;
-
-/**
-
-
- */
-public class PlayerLeavePlotEvent extends PlayerEvent {
-    
-    private static 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(final Player player, final Plot plot) {
-        super(player);
-        this.plot = plot;
-    }
-    
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-    
-    /**
-     * Get the plot involved
-     *
-     * @return Plot
-     */
-    public Plot getPlot() {
-        return plot;
-    }
-    
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;

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

@@ -1,89 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// PlotSquared - A plot manager and world generator for the Bukkit API                             /
-// Copyright (c) 2014 IntellectualSites/IntellectualCrafters                                       /
-//                                                                                                 /
-// This program is free software; you can redistribute it and/or modify                            /
-// it under the terms of the GNU General Public License as published by                            /
-// the Free Software Foundation; either version 3 of the License, or                               /
-// (at your option) any later version.                                                             /
-//                                                                                                 /
-// This program is distributed in the hope that it will be useful,                                 /
-// but WITHOUT ANY WARRANTY; without even the implied warranty of                                  /
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                   /
-// GNU General Public License for more details.                                                    /
-//                                                                                                 /
-// You should have received a copy of the GNU General Public License                               /
-// along with this program; if not, write to the Free Software Foundation,                         /
-// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA                               /
-//                                                                                                 /
-// You can contact us via: support@intellectualsites.com                                           /
-////////////////////////////////////////////////////////////////////////////////////////////////////
-package com.plotsquared.bukkit.events;
-
-import java.util.UUID;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.HandlerList;
-
-import com.intellectualcrafters.plot.object.Plot;
-
-/**
-
-
- */
-public class PlayerPlotDeniedEvent extends PlotEvent {
-    
-    private static 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(final Player initiator, final Plot plot, final UUID player, final 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 added;
-    }
-    
-    /**
-     * The player added/removed
-     *
-     * @return UUID
-     */
-    public UUID getPlayer() {
-        return player;
-    }
-    
-    /**
-     * The player initiating the action
-     *
-     * @return Player
-     */
-    public Player getInitiator() {
-        return initiator;
-    }
-    
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;

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

@@ -1,89 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// PlotSquared - A plot manager and world generator for the Bukkit API                             /
-// Copyright (c) 2014 IntellectualSites/IntellectualCrafters                                       /
-//                                                                                                 /
-// This program is free software; you can redistribute it and/or modify                            /
-// it under the terms of the GNU General Public License as published by                            /
-// the Free Software Foundation; either version 3 of the License, or                               /
-// (at your option) any later version.                                                             /
-//                                                                                                 /
-// This program is distributed in the hope that it will be useful,                                 /
-// but WITHOUT ANY WARRANTY; without even the implied warranty of                                  /
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                   /
-// GNU General Public License for more details.                                                    /
-//                                                                                                 /
-// You should have received a copy of the GNU General Public License                               /
-// along with this program; if not, write to the Free Software Foundation,                         /
-// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA                               /
-//                                                                                                 /
-// You can contact us via: support@intellectualsites.com                                           /
-////////////////////////////////////////////////////////////////////////////////////////////////////
-package com.plotsquared.bukkit.events;
-
-import java.util.UUID;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.HandlerList;
-
-import com.intellectualcrafters.plot.object.Plot;
-
-/**
-
-
- */
-public class PlayerPlotHelperEvent extends PlotEvent {
-    
-    private static 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(final Player initiator, final Plot plot, final UUID player, final 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 added;
-    }
-    
-    /**
-     * The UUID added/removed
-     *
-     * @return UUID
-     */
-    public UUID getPlayer() {
-        return player;
-    }
-    
-    /**
-     * The player initiating the action
-     *
-     * @return Player
-     */
-    public Player getInitiator() {
-        return initiator;
-    }
-    
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;

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

@@ -1,89 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// PlotSquared - A plot manager and world generator for the Bukkit API                             /
-// Copyright (c) 2014 IntellectualSites/IntellectualCrafters                                       /
-//                                                                                                 /
-// This program is free software; you can redistribute it and/or modify                            /
-// it under the terms of the GNU General Public License as published by                            /
-// the Free Software Foundation; either version 3 of the License, or                               /
-// (at your option) any later version.                                                             /
-//                                                                                                 /
-// This program is distributed in the hope that it will be useful,                                 /
-// but WITHOUT ANY WARRANTY; without even the implied warranty of                                  /
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                   /
-// GNU General Public License for more details.                                                    /
-//                                                                                                 /
-// You should have received a copy of the GNU General Public License                               /
-// along with this program; if not, write to the Free Software Foundation,                         /
-// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA                               /
-//                                                                                                 /
-// You can contact us via: support@intellectualsites.com                                           /
-////////////////////////////////////////////////////////////////////////////////////////////////////
-package com.plotsquared.bukkit.events;
-
-import java.util.UUID;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.HandlerList;
-
-import com.intellectualcrafters.plot.object.Plot;
-
-/**
-
-
- */
-public class PlayerPlotTrustedEvent extends PlotEvent {
-    
-    private static 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(final Player initiator, final Plot plot, final UUID player, final 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 added;
-    }
-    
-    /**
-     * The UUID added/removed
-     *
-     * @return UUID
-     */
-    public UUID getPlayer() {
-        return player;
-    }
-    
-    /**
-     * The player initiating the action
-     *
-     * @return Player
-     */
-    public Player getInitiator() {
-        return initiator;
-    }
-    
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;

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

@@ -1,90 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// PlotSquared - A plot manager and world generator for the Bukkit API                             /
-// Copyright (c) 2014 IntellectualSites/IntellectualCrafters                                       /
-//                                                                                                 /
-// This program is free software; you can redistribute it and/or modify                            /
-// it under the terms of the GNU General Public License as published by                            /
-// the Free Software Foundation; either version 3 of the License, or                               /
-// (at your option) any later version.                                                             /
-//                                                                                                 /
-// This program is distributed in the hope that it will be useful,                                 /
-// but WITHOUT ANY WARRANTY; without even the implied warranty of                                  /
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                   /
-// GNU General Public License for more details.                                                    /
-//                                                                                                 /
-// You should have received a copy of the GNU General Public License                               /
-// along with this program; if not, write to the Free Software Foundation,                         /
-// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA                               /
-//                                                                                                 /
-// You can contact us via: support@intellectualsites.com                                           /
-////////////////////////////////////////////////////////////////////////////////////////////////////
-package com.plotsquared.bukkit.events;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.player.PlayerEvent;
-
-import com.intellectualcrafters.plot.object.Location;
-import com.intellectualcrafters.plot.object.Plot;
-
-/**
- * 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(final Player player, final Location from, final 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 from;
-    }
-    
-    /**
-     * Get the plot involved
-     *
-     * @return Plot
-     */
-    public Plot getPlot() {
-        return plot;
-    }
-    
-    @Override
-    public boolean isCancelled() {
-        return cancelled;
-    }
-    
-    @Override
-    public void setCancelled(final boolean cancelled) {
-        this.cancelled = cancelled;