Clean gradle target directory

Add some 1.9 blocks to chest content with schematic paste
Restructure tileentity placement from schematic (will soon add signs
etc)
Prepare for release 3.3.3

.github/CONTRIBUTING.md

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

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,12 @@
+# Bug report template (Follow this template unless you are making a feature request.)
+**Debug paste link**:
+
+**Description of the problem:**
+
+**How to replicate**:
+
+Make sure you've completed the following steps (put an X between 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

.gitignore

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

Bukkit/build.gradle

@@ -0,0 +1,38 @@
+dependencies {
+    compile project(':Core')
+    compile 'org.bukkit:bukkit:1.9-R0.1-SNAPSHOT'
+    compile 'org.mcstats.bukkit:metrics:R7'
+    compile 'net.milkbowl.vault:VaultAPI:1.5'
+}
+
+sourceCompatibility = 1.7
+targetCompatibility = 1.7
+
+processResources {
+    from('src/main/resources') {
+        include 'plugin.yml'
+        expand(
+            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'))
+        include(dependency('org.mcstats.bukkit:metrics:R7'))
+    }
+    relocate 'org.mcstats', 'com.plotsquared.stats'
+    archiveName = "${parent.name}-${project.name}-${parent.version}.jar"
+    destinationDir = file '../target'
+}
+shadowJar.doLast {
+    task ->
+    ant.checksum file: task.archivePath
+}
+
+build.dependsOn(shadowJar);

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

@@ -0,0 +1,760 @@
+package com.intellectualcrafters.plot.api;
+
+import com.intellectualcrafters.configuration.file.YamlConfiguration;
+import com.intellectualcrafters.plot.PS;
+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.
+ * <br>
+ * <br>
+ * Useful classes:<br>
+ * @see BukkitUtil
+ * @see PlotPlayer
+ * @see Plot
+ * @see com.intellectualcrafters.plot.object.Location
+ * @see PlotArea
+ * @see PS
+ * @version 3.3.3
+>>>>>>> origin/master
+ */
+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 instead
+     */
+    @Deprecated
+    public static final String ADMIN_PERMISSION = C.PERMISSION_ADMIN.s();
+
+    /**
+     * Deprecated, does nothing.
+     * @param plugin not needed
+     * @deprecated Not needed
+     */
+    @Deprecated
+    public PlotAPI(JavaPlugin plugin) {
+    }
+
+    /**
+     * Default Constructor that does nothing.
+     *
+     * @deprecated Use this class if you just want to do a few simple things
+     *      <ul>
+     *          <li>It will remain stable for future versions
+     *              of the plugin</li>
+     *          <li>The PlotPlayer and Plot class should be considered
+     *              relatively safe</li>
+     *          <li>For more advanced/intensive tasks you should consider
+     *              using other classes</li>
+     *      </ul>
+     *
+     */
+    @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(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(PlotArea plotArea) {
+        PS.get().addPlotArea(plotArea);
+    }
+
+    /**
+     * Returns the PlotSquared configurations file.
+     * @return main configuration
+     *
+     * @see PS#config
+     */
+    public YamlConfiguration getConfig() {
+        return PS.get().config;
+    }
+
+    /**
+     * Get the PlotSquared storage file.
+     * @return storage configuration
+     *
+     * @see PS#storage
+     */
+    public YamlConfiguration getStorage() {
+        return PS.get().storage;
+    }
+
+    /**
+     * Get the main class for this plugin. 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.
+     * <ul>
+     *     <li>Chunk deletion</li>
+     *     <li>Moving or copying regions</li>
+     *     <li>Plot swapping</li>
+     *     <li>Entity Tracking</li>
+     *     <li>Region Regeneration</li>
+     * </ul>
+     *
+     * @return ChunkManager
+     *
+     * @see 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
+     *
+     * @deprecated Use {@link FlagManager} directly
+     */
+    @Deprecated
+    public FlagManager getFlagManager() {
+        return new FlagManager();
+    }
+
+    /**
+     * Do not use this. Instead use MainUtil.[method] in your code.
+     *
+     * @return MainUtil
+     * @deprecated Use {@link MainUtil} directly
+     */
+    @Deprecated
+    public MainUtil getMainUtil() {
+        return new MainUtil();
+    }
+
+    /**
+     * Do not use this. Instead use C.PERMISSION_[method] in your code.
+     *
+     * @return Array of strings
+     *
+     * @see com.intellectualcrafters.plot.util.Permissions
+     * @deprecated Use {@link C} to list all the permissions
+     */
+    @Deprecated
+    public String[] getPermissions() {
+        ArrayList<String> perms = new ArrayList<>();
+        for (C c : C.values()) {
+            if ("static.permissions".equals(c.getCategory())) {
+                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
+     * @deprecated Use {@link 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(World world) {
+        if (world == null) {
+            return null;
+        }
+        return getPlotManager(world.getName());
+    }
+
+    /**
+     * Get a list of PlotAreas in the world.
+     * @param world The world to check for plot areas
+     * @return A set of PlotAreas
+     */
+    public Set<PlotArea> getPlotAreas(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 The world
+     *
+     * @return PlotManager
+     *
+     * @see PS#getPlotManager(Plot)
+     * @see com.intellectualcrafters.plot.object.PlotManager
+     */
+    @Deprecated
+    public PlotManager getPlotManager(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 The World
+     *
+     * @return The {@link PlotArea} for the world or null if not in plotworld
+     *
+     * @see #getPlotAreas(World)
+     * @see com.intellectualcrafters.plot.object.PlotArea
+     */
+    @Deprecated
+    public PlotArea getWorldSettings(World world) {
+        if (world == null) {
+            return null;
+        }
+        return getWorldSettings(world.getName());
+    }
+
+    /**
+     * Get the settings for a world.
+     *
+     * @param world The world
+     *
+     * @return The {@link PlotArea} for the world or null if not in plotworld
+     *
+     * @see PS#getPlotArea(String, String)
+     * @see com.intellectualcrafters.plot.object.PlotArea
+     */
+    @Deprecated
+    public PlotArea getWorldSettings(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 caption Caption
+     *
+     * @see MainUtil#sendMessage(PlotPlayer, C, String...)
+     */
+    public void sendMessage(Player player, C caption) {
+        MainUtil.sendMessage(BukkitUtil.getPlayer(player), caption);
+    }
+
+    /**
+     * 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(Player player, String string) {
+        MainUtil.sendMessage(BukkitUtil.getPlayer(player), string);
+    }
+
+    /**
+     * Send a message to the console. Supports color codes.
+     *
+     * @param message Message that should be sent to the console
+     *
+     * @see MainUtil#sendConsoleMessage(C, String...)
+     */
+    public void sendConsoleMessage(String message) {
+        PS.log(message);
+    }
+
+    /**
+     * Send a message to the console.
+     *
+     * @param caption The caption
+     *
+     * @see #sendConsoleMessage(String)
+     * @see com.intellectualcrafters.plot.config.C
+     */
+    public void sendConsoleMessage(C caption) {
+        sendConsoleMessage(caption.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(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 The PlotID x coordinate
+     * @param z The PlotID y coordinate
+     *
+     * @return plot, null if ID is wrong
+     *
+     * @see PlotArea#getPlot(PlotId)
+     */
+    @Deprecated
+    public Plot getPlot(World world, int x, 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 location The location to retrieve the plot from
+     *
+     * @return plot if found, otherwise it creates a temporary plot
+     *
+     * @see Plot
+     */
+    public Plot getPlot(Location location) {
+        if (location == null) {
+            return null;
+        }
+        return BukkitUtil.getLocation(location).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(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
+     * @param world The world to check
+     * @return true if player has a plot, false if not.
+     *
+     * @see #getPlots(World, Player, boolean)
+     */
+    @Deprecated
+    public boolean hasPlot(World world, Player player) {
+        return getPlots(world, player, true).length > 0;
+    }
+
+    /**
+     * Get all plots for the player.
+     *
+     * @param world The world to retrieve plots from
+     * @param player The player to search for
+     * @param justOwner should we just search for owner? Or with rights?
+     * @return An array of plots for the player
+     */
+    @Deprecated
+    public Plot[] getPlots(World world, Player player, boolean justOwner) {
+        ArrayList<Plot> pPlots = new ArrayList<>();
+        UUID uuid = BukkitUtil.getPlayer(player).getUUID();
+        for (Plot plot : PS.get().getPlots(world.getName())) {
+            if (justOwner) {
+                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(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 plotworld.
+     *
+     * @param world The world to check
+     *
+     * @return boolean (if plot world or not)
+     *
+     * @see PS#hasPlotArea(String)
+     */
+    @Deprecated
+    public boolean isPlotWorld(World world) {
+        return PS.get().hasPlotArea(world.getName());
+    }
+
+    /**
+     * Get plot locations.
+     *
+     * @param plot Plot 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(Plot plot) {
+        Location bukkitBottom = BukkitUtil.getLocation(plot.getCorners()[0]);
+        Location bukkitTop = BukkitUtil.getLocation(plot.getCorners()[1]);
+        Location bukkitHome = BukkitUtil.getLocation(plot.getHome());
+        return new Location[]{bukkitBottom, bukkitTop, bukkitHome};
+    }
+
+    /**
+     * Get home location.
+     *
+     * @param plot Plot that you want to get the location for
+     *
+     * @return plot bottom location
+     *
+     * @see Plot
+     */
+    public Location getHomeLocation(Plot plot) {
+        return BukkitUtil.getLocation(plot.getHome());
+    }
+
+    /**
+     * Get Bottom Location (min, min, min).
+     *
+     * @param plot 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(Plot plot) {
+        return BukkitUtil.getLocation(plot.getBottom());
+    }
+
+    /**
+     * Get Top Location (max, max, max).
+     *
+     * @param plot 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(Plot plot) {
+        return BukkitUtil.getLocation(plot.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(Player player) {
+        return getPlot(player) != null;
+    }
+
+    /**
+     * Register a subcommand.
+     * @deprecated Command registration is done on object creation
+     * @param c SubCommand, that we want to register
+     * @see com.intellectualcrafters.plot.commands.SubCommand
+     */
+    @Deprecated
+    public void registerCommand(SubCommand c) {
+        PS.debug("SubCommands are now registered on creation");
+    }
+
+    /**
+     * 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(World world, 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(World world, 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
+     *
+     * @return the number of allowed plots
+     *
+     */
+    public int getAllowedPlots(Player player) {
+        PlotPlayer pp = BukkitUtil.getPlayer(player);
+        return pp.getAllowedPlots();
+    }
+
+    /**
+     * Get the PlotPlayer for a player. The PlotPlayer is usually cached and
+     * will provide useful functions relating to players.
+     *
+     * @see PlotPlayer#wrap(Object)
+     *
+     * @param player The player to wrap
+     * @return A PlotPlayer
+     */
+    public PlotPlayer wrapPlayer(Player player) {
+        return PlotPlayer.wrap(player);
+    }
+
+    /**
+     * Get the PlotPlayer for a UUID.
+     *
+     * <p><i>Please note that PlotSquared can be configured to provide
+     * different UUIDs than bukkit</i></p>
+     *
+     * @see PlotPlayer#wrap(Object)
+     *
+     * @param uuid The uuid of the player to wrap
+     * @return A PlotPlayer
+     */
+    public PlotPlayer wrapPlayer(UUID uuid) {
+        return PlotPlayer.wrap(uuid);
+    }
+
+    /**
+     * Get the PlotPlayer for a username.
+     *
+     * @see PlotPlayer#wrap(Object)
+     *
+     * @param player The player to wrap
+     * @return The PlotPlayer
+     */
+    public PlotPlayer wrapPlayer(String player) {
+        return PlotPlayer.wrap(player);
+    }
+
+    /**
+     * Get the PlotPlayer for an offline player.
+     * <p>Note that this will work if the player is offline, however not all
+     * functionality will work</p>
+     *
+     * @see PlotPlayer#wrap(Object)
+     *
+     * @param player The player to wrap
+     * @return The PlotPlayer
+     */
+    public PlotPlayer wrapPlayer(OfflinePlayer player) {
+        return PlotPlayer.wrap(player);
+    }
+}

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

@@ -0,0 +1,670 @@
+package com.plotsquared.bukkit;
+
+import com.intellectualcrafters.configuration.ConfigurationSection;
+import com.intellectualcrafters.plot.IPlotMain;
+import com.intellectualcrafters.plot.PS;
+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.Plot;
+import com.intellectualcrafters.plot.object.PlotArea;
+import com.intellectualcrafters.plot.object.PlotPlayer;
+import com.intellectualcrafters.plot.object.RunnableVal;
+import com.intellectualcrafters.plot.object.SetupObject;
+import com.intellectualcrafters.plot.util.AbstractTitle;
+import com.intellectualcrafters.plot.util.ChatManager;
+import com.intellectualcrafters.plot.util.ChunkManager;
+import com.intellectualcrafters.plot.util.ConsoleColors;
+import com.intellectualcrafters.plot.util.EconHandler;
+import com.intellectualcrafters.plot.util.EventUtil;
+import com.intellectualcrafters.plot.util.InventoryUtil;
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.PlotQueue;
+import com.intellectualcrafters.plot.util.SchematicHandler;
+import com.intellectualcrafters.plot.util.SetupUtils;
+import com.intellectualcrafters.plot.util.StringMan;
+import com.intellectualcrafters.plot.util.TaskManager;
+import com.intellectualcrafters.plot.util.UUIDHandler;
+import com.intellectualcrafters.plot.util.UUIDHandlerImplementation;
+import com.intellectualcrafters.plot.util.WorldUtil;
+import com.intellectualcrafters.plot.uuid.UUIDWrapper;
+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.ChunkListener;
+import com.plotsquared.bukkit.listeners.ForceFieldListener;
+import com.plotsquared.bukkit.listeners.PlayerEvents;
+import com.plotsquared.bukkit.listeners.PlayerEvents183;
+import com.plotsquared.bukkit.listeners.PlayerEvents_1_8;
+import com.plotsquared.bukkit.listeners.PlayerEvents_1_9;
+import com.plotsquared.bukkit.listeners.PlotPlusListener;
+import com.plotsquared.bukkit.listeners.WorldEvents;
+import com.plotsquared.bukkit.listeners.worldedit.WEListener;
+import com.plotsquared.bukkit.titles.DefaultTitle_19;
+import com.plotsquared.bukkit.util.BukkitChatManager;
+import com.plotsquared.bukkit.util.BukkitChunkManager;
+import com.plotsquared.bukkit.util.BukkitCommand;
+import com.plotsquared.bukkit.util.BukkitEconHandler;
+import com.plotsquared.bukkit.util.BukkitEventUtil;
+import com.plotsquared.bukkit.util.BukkitHybridUtils;
+import com.plotsquared.bukkit.util.BukkitInventoryUtil;
+import com.plotsquared.bukkit.util.BukkitPlainChatManager;
+import com.plotsquared.bukkit.util.BukkitSchematicHandler;
+import com.plotsquared.bukkit.util.BukkitSetupUtils;
+import com.plotsquared.bukkit.util.BukkitTaskManager;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.bukkit.util.Metrics;
+import com.plotsquared.bukkit.util.SendChunk;
+import com.plotsquared.bukkit.util.SetGenCB;
+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.FastQueue_1_9;
+import com.plotsquared.bukkit.util.block.SlowQueue;
+import com.plotsquared.bukkit.uuid.DefaultUUIDWrapper;
+import com.plotsquared.bukkit.uuid.FileUUIDHandler;
+import com.plotsquared.bukkit.uuid.LowerOfflineUUIDWrapper;
+import com.plotsquared.bukkit.uuid.OfflineUUIDWrapper;
+import com.plotsquared.bukkit.uuid.SQLUUIDHandler;
+import com.sk89q.worldedit.bukkit.WorldEditPlugin;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.UUID;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.World;
+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;
+
+public class BukkitMain extends JavaPlugin implements Listener, IPlotMain {
+
+    public static BukkitMain THIS;
+    public static WorldEditPlugin worldEdit;
+
+    private int[] version;
+
+    @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();
+                PS.debug(StringMan.getString(Bukkit.getBukkitVersion()));
+                PS.debug(StringMan.getString(Bukkit.getBukkitVersion().split("-")[0].split("\\.")));
+                return new int[]{Integer.MAX_VALUE, 0, 0};
+            }
+        }
+        return this.version;
+    }
+
+    @Override
+    public void onEnable() {
+        BukkitMain.THIS = this;
+        new PS(this, "Bukkit");
+    }
+
+    @Override
+    public void onDisable() {
+        PS.get().disable();
+        Bukkit.getScheduler().cancelTasks(this);
+        BukkitMain.THIS = null;
+    }
+
+    @Override
+    public void log(String message) {
+        if (BukkitMain.THIS != null) {
+            try {
+                message = C.color(message);
+                if (!Settings.CONSOLE_COLOR) {
+                    message = ChatColor.stripColor(message);
+                }
+                this.getServer().getConsoleSender().sendMessage(message);
+                return;
+            } catch (Throwable ignored) {
+                //ignored
+            }
+        }
+        System.out.println(ConsoleColors.fromString(message));
+    }
+
+    @Override
+    public void disable() {
+        if (BukkitMain.THIS != null) {
+            onDisable();
+        }
+    }
+
+    @Override
+    public int[] getPluginVersion() {
+        String version = getDescription().getVersion();
+        if (version.contains("-SNAPSHOT")) {
+            version = version.split("-SNAPSHOT")[0];
+        }
+        String[] split = version.split("\\.");
+        return new int[]{Integer.parseInt(split[0]), Integer.parseInt(split[1]), Integer.parseInt(split[2])};
+    }
+
+    @Override
+    public void registerCommands() {
+        BukkitCommand bukkitCommand = new BukkitCommand();
+        PluginCommand plotCommand = getCommand("plots");
+        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();
+    }
+
+    @Override
+    public void runEntityTask() {
+        log(C.PREFIX + "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> iterator = entities.iterator();
+                            while (iterator.hasNext()) {
+                                Entity entity = iterator.next();
+                                switch (entity.getType()) {
+                                    case EGG:
+                                    case ENDER_CRYSTAL:
+                                    case COMPLEX_PART:
+                                    case FISHING_HOOK:
+                                    case ENDER_SIGNAL:
+                                    case AREA_EFFECT_CLOUD:
+                                    case EXPERIENCE_ORB:
+                                    case LEASH_HITCH:
+                                    case FIREWORK:
+                                    case WEATHER:
+                                    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 TIPPED_ARROW:
+                                    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 location = BukkitUtil.getLocation(entity.getLocation());
+                                        Plot plot = location.getPlot();
+                                        if (plot == null) {
+                                            if (location.isPlotArea()) {
+                                                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))) {
+                                            iterator.remove();
+                                            entity.remove();
+                                        }
+                                        continue;
+                                    }
+                                    case SMALL_FIREBALL:
+                                    case FIREBALL:
+                                    case DRAGON_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:
+                                    case SHULKER:
+                                    default:
+                                        if (!Settings.KILL_ROAD_MOBS) {
+                                            continue;
+                                        }
+                                        Location location = entity.getLocation();
+                                        if (BukkitUtil.getLocation(location).isPlotRoad()) {
+                                            Entity passenger = entity.getPassenger();
+                                            if (!(passenger instanceof Player) && entity.getMetadata("keep").isEmpty()) {
+                                                iterator.remove();
+                                                entity.remove();
+                                            }
+                                        }
+                                }
+                            }
+                        } catch (Throwable e) {
+                            e.printStackTrace();
+                        }
+                    }
+                });
+            }
+        }, 20);
+    }
+
+    @Override
+    public final ChunkGenerator getDefaultWorldGenerator(String world, String id) {
+        HybridGen result = new HybridGen();
+        if (!PS.get().setupPlotWorld(world, id, result)) {
+            return null;
+        }
+        return (ChunkGenerator) result.specify();
+    }
+
+    @Override
+    public void registerPlayerEvents() {
+        PlayerEvents main = new PlayerEvents();
+        getServer().getPluginManager().registerEvents(main, 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 PlayerEvents183(), this);
+        }
+        if (PS.get().checkVersion(getServerVersion(), 1, 9, 0)) {
+            getServer().getPluginManager().registerEvents(new PlayerEvents_1_9(main), 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) {
+            worldEdit = (WorldEditPlugin) getServer().getPluginManager().getPlugin("WorldEdit");
+            getServer().getPluginManager().registerEvents(new WEListener(), this);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public EconHandler getEconomyHandler() {
+        try {
+            BukkitEconHandler econ = new BukkitEconHandler();
+            if (econ.init()) {
+                return econ;
+            }
+        } catch (Throwable ignored) {
+            PS.debug("No economy detected!");
+        }
+        return null;
+    }
+
+    @Override
+    public PlotQueue initPlotQueue() {
+        try {
+            new SendChunk();
+            MainUtil.canSendChunk = true;
+        } catch (Throwable e) {
+            e.printStackTrace();
+            MainUtil.canSendChunk = false;
+        }
+        if (PS.get().checkVersion(getServerVersion(), 1, 9, 0)) {
+            try {
+                return new FastQueue_1_9();
+            } catch (Throwable e) {
+                e.printStackTrace();
+                return new SlowQueue();
+            }
+        }
+        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(String world, String name) {
+        if (name == null) {
+            return null;
+        }
+        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(new HybridGen());
+        }
+    }
+
+    @Override
+    public HybridUtils initHybridUtils() {
+        return new BukkitHybridUtils();
+    }
+
+    @Override
+    public SetupUtils initSetupUtils() {
+        return new BukkitSetupUtils();
+    }
+
+    @Override
+    public UUIDHandlerImplementation initUUIDHandler() {
+        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 + " &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_19();
+            if (wrapper instanceof DefaultUUIDWrapper || wrapper.getClass() == OfflineUUIDWrapper.class && !Bukkit.getOnlineMode()) {
+                Settings.TWIN_MODE_UUID = true;
+            }
+        }
+        if (Settings.OFFLINE_MODE) {
+            log(C.PREFIX
+                    + " &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 + " &6PlotSquared is using online UUIDs");
+        }
+        if (Settings.USE_SQLUUIDHANDLER) {
+            return new SQLUUIDHandler(wrapper);
+        } else {
+            return new FileUUIDHandler(wrapper);
+        }
+    }
+
+    @Override
+    public ChunkManager initChunkManager() {
+        return new BukkitChunkManager();
+    }
+
+    @Override
+    public EventUtil initEventUtil() {
+        return new BukkitEventUtil();
+    }
+
+    @Override
+    public void unregister(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() {
+        Metrics metrics = new Metrics(this);
+        metrics.start();
+        log(C.PREFIX + "&6Metrics enabled.");
+    }
+
+    @Override
+    public void setGenerator(String worldName) {
+        World world = BukkitUtil.getWorld(worldName);
+        if (world == null) {
+            // create world
+            ConfigurationSection worldConfig = PS.get().config.getConfigurationSection("worlds." + worldName);
+            String manager = worldConfig.getString("generator.plugin", "PlotSquared");
+            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);
+        } else {
+            try {
+                if (!PS.get().hasPlotArea(worldName)) {
+                    SetGenCB.setGenerator(BukkitUtil.getWorld(worldName));
+                }
+            } catch (Exception e) {
+                log("Failed to reload world: " + world);
+                Bukkit.getServer().unloadWorld(world, false);
+            }
+        }
+        world = Bukkit.getWorld(worldName);
+        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(Object player) {
+        if (player instanceof Player) {
+            return BukkitUtil.getPlayer((Player) player);
+        } else if (player instanceof OfflinePlayer) {
+            return BukkitUtil.getPlayer((OfflinePlayer) player);
+        } else if (player instanceof String) {
+            return UUIDHandler.getPlayer((String) player);
+        } else if (player instanceof UUID) {
+            return UUIDHandler.getPlayer((UUID) player);
+        }
+        return null;
+    }
+
+    @Override
+    public String getNMSPackage() {
+        String name = Bukkit.getServer().getClass().getPackage().getName();
+        return name.substring(name.lastIndexOf('.') + 1);
+    }
+
+    @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/chat/ArrayWrapper.java

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

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

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

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

@@ -0,0 +1,19 @@
+package com.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(JsonWriter writer) throws IOException;
+
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,313 @@
+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() {
+        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 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");
+
+        HashSet<String> worlds = new HashSet<>();
+        worlds.add(WorldUtil.IMP.getMainWorld());
+        worlds.add("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 FilenameFilter() {
+                @Override
+                public boolean accept(File f, String s) {
+                    return s.endsWith(".dat");
+                }
+            });
+            if (dat != null) {
+                for (String current : dat) {
+                    String s = current.replaceAll(".dat$", "");
+                    try {
+                        UUID uuid = UUID.fromString(s);
+                        uuids.add(uuid);
+                    } catch (Exception e) {
+                        MainUtil.sendMessage(player, C.PREFIX + "Invalid playerdata: " + current);
+                    }
+                }
+            }
+            File playersFolder = new File(worldName + File.separator + "players");
+            dat = playersFolder.list(new FilenameFilter() {
+                @Override
+                public boolean accept(File f, String s) {
+                    return s.endsWith(".dat");
+                }
+            });
+            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 e) {
+                MainUtil.sendMessage(player, C.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.getName();
+                    //                    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(new Runnable() {
+            @Override
+            public void run() {
+                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(PS.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 : PS.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");
+                final AbstractDB database = DBFunc.dbManager;
+                boolean result = database.deleteTables();
+
+                MainUtil.sendMessage(player, "&7 - Creating tables");
+
+                try {
+                    database.createTables();
+                    if (!result) {
+                        MainUtil.sendMessage(player, "&cConversion failed! Attempting recovery");
+                        for (Plot plot : PS.get().getPlots()) {
+                            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 (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 manual set!");
+                }
+
+                MainUtil.sendMessage(player, "&7 - Populating tables");
+
+                TaskManager.runTaskAsync(new Runnable() {
+                    @Override
+                    public void run() {
+                        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

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

@@ -0,0 +1,272 @@
+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(String plugin, FileConfiguration plotConfig, String dataFolder) {
+        this.plugin = plugin.toLowerCase();
+        this.prefix = plotConfig.getString("mySQLprefix", plugin.toLowerCase());
+        try {
+            if (plotConfig.getBoolean("usemySQL")) {
+                String user = plotConfig.getString("mySQLuname");
+                String password = plotConfig.getString("mySQLpass");
+                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) {
+            //ignored
+            ignored.printStackTrace();
+        }
+        return null;
+    }
+
+    @Override
+    public HashMap<String, HashMap<PlotId, Plot>> getPlotMePlots(Connection connection) throws SQLException {
+        HashMap<String, Integer> plotWidth = new HashMap<>();
+        HashMap<String, Integer> roadWidth = new HashMap<>();
+        HashMap<String, HashMap<PlotId, Plot>> plots = new HashMap<>();
+        HashMap<String, HashMap<PlotId, boolean[]>> merges = new HashMap<>();
+        PreparedStatement statement = connection.prepareStatement("SELECT * FROM `" + this.prefix + "Plots`");
+        ResultSet resultSet = statement.executeQuery();
+        String column = null;
+        boolean checkUUID = DBFunc.hasColumn(resultSet, "ownerid");
+        boolean checkUUID2 = DBFunc.hasColumn(resultSet, "ownerId");
+        if (checkUUID) {
+            column = "ownerid";
+        } else if (checkUUID2) {
+            column = "ownerId";
+        }
+        boolean merge = !"plotme".equalsIgnoreCase(this.plugin) && Settings.CONVERT_PLOTME;
+        int missing = 0;
+        while (resultSet.next()) {
+            PlotId id = new PlotId(resultSet.getInt("idX"), resultSet.getInt("idZ"));
+            String name = resultSet.getString("owner");
+            String world = LikePlotMeConverter.getWorld(resultSet.getString("world"));
+            if (!plots.containsKey(world)) {
+                plots.put(world, new HashMap<PlotId, Plot>());
+                if (merge) {
+                    int plot = PS.get().config.getInt("worlds." + world + ".plot.size");
+                    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) {
+                int tx = resultSet.getInt("topX");
+                int tz = resultSet.getInt("topZ");
+                int bx = resultSet.getInt("bottomX") - 1;
+                int bz = resultSet.getInt("bottomZ") - 1;
+                int path = roadWidth.get(world);
+                int plot = plotWidth.get(world);
+                Location top = getPlotTopLocAbs(path, plot, id);
+                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 {
+                            byte[] bytes = resultSet.getBytes(column);
+                            if (bytes != null) {
+                                try {
+                                    ByteBuffer bb = ByteBuffer.wrap(bytes);
+                                    long high = bb.getLong();
+                                    long low = bb.getLong();
+                                    owner = new UUID(high, low);
+                                } catch (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()) {
+                            PS.log("&cCould not identify owner for plot: " + id + " -> '" + name + "'");
+                            missing++;
+                            continue;
+                        }
+                        owner = UUID.nameUUIDFromBytes(("OfflinePlayer:" + name.toLowerCase()).getBytes(Charsets.UTF_8));
+                    }
+                }
+            } else {
+                UUIDHandler.add(new StringWrapper(name), owner);
+            }
+            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 (Entry<String, HashMap<PlotId, boolean[]>> entry : merges.entrySet()) {
+            String world = entry.getKey();
+            for (Entry<PlotId, boolean[]> entry2 : entry.getValue().entrySet()) {
+                HashMap<PlotId, Plot> newPlots = plots.get(world);
+                Plot plot = newPlots.get(entry2.getKey());
+                if (plot != null) {
+                    plot.setMerged(entry2.getValue());
+                }
+            }
+        }
+
+        resultSet.close();
+        statement.close();
+
+        try {
+
+            PS.log(" - " + this.prefix + "Denied");
+            statement = connection.prepareStatement("SELECT * FROM `" + this.prefix + "Denied`");
+            resultSet = statement.executeQuery();
+
+            while (resultSet.next()) {
+                PlotId id = new PlotId(resultSet.getInt("idX"), resultSet.getInt("idZ"));
+                String name = resultSet.getString("player");
+                String world = LikePlotMeConverter.getWorld(resultSet.getString("world"));
+                UUID denied = UUIDHandler.getUUID(name, null);
+                if (denied == null) {
+                    if ("*".equals(name)) {
+                        denied = DBFunc.everyone;
+                    } else if (DBFunc.hasColumn(resultSet, "playerid")) {
+                        try {
+                            byte[] bytes = resultSet.getBytes("playerid");
+                            if (bytes != null) {
+                                try {
+                                    ByteBuffer bb = ByteBuffer.wrap(bytes);
+                                    long high = bb.getLong();
+                                    long low = bb.getLong();
+                                    denied = new UUID(high, low);
+                                } catch (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;
+                    }
+                }
+                HashMap<PlotId, Plot> worldMap = plots.get(world);
+                if (worldMap != null) {
+                    Plot plot = worldMap.get(id);
+                    if (plot != null) {
+                        plot.getDenied().add(denied);
+                    }
+                }
+            }
+
+            statement = connection.prepareStatement("SELECT * FROM `" + this.plugin + "Allowed`");
+            resultSet = statement.executeQuery();
+
+            while (resultSet.next()) {
+                PlotId id = new PlotId(resultSet.getInt("idX"), resultSet.getInt("idZ"));
+                String name = resultSet.getString("player");
+                String world = LikePlotMeConverter.getWorld(resultSet.getString("world"));
+                UUID helper = UUIDHandler.getUUID(name, null);
+                if (helper == null) {
+                    if ("*".equals(name)) {
+                        helper = DBFunc.everyone;
+                    } else if (DBFunc.hasColumn(resultSet, "playerid")) {
+                        try {
+                            byte[] bytes = resultSet.getBytes("playerid");
+                            if (bytes != null) {
+                                try {
+                                    ByteBuffer bb = ByteBuffer.wrap(bytes);
+                                    long high = bb.getLong();
+                                    long low = bb.getLong();
+                                    helper = new UUID(high, low);
+                                } catch (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;
+                    }
+                }
+                HashMap<PlotId, Plot> worldMap = plots.get(world);
+                if (worldMap != null) {
+                    Plot plot = worldMap.get(id);
+                    if (plot != null) {
+                        plot.getTrusted().add(helper);
+                    }
+                }
+            }
+
+            resultSet.close();
+            statement.close();
+
+        } catch (SQLException ignored) {
+            //ignored
+        }
+        return plots;
+    }
+
+    @Override
+    public boolean accepts(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

@@ -0,0 +1,377 @@
+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 org.bukkit.command.CommandException;
+
+import java.io.File;
+import java.io.IOException;
+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;
+
+public class LikePlotMeConverter {
+
+    private final String plugin;
+
+    /**
+     * Constructor.
+     *
+     * @param plugin Plugin Used to run the converter
+     */
+    public LikePlotMeConverter(String plugin) {
+        this.plugin = plugin;
+    }
+
+    public static String getWorld(String world) {
+        for (World newWorld : Bukkit.getWorlds()) {
+            if (newWorld.getName().equalsIgnoreCase(world)) {
+                return newWorld.getName();
+            }
+        }
+        return world;
+    }
+
+    private void sendMessage(String message) {
+        PS.debug("&3PlotMe&8->&3PlotSquared&8: &7" + message);
+    }
+
+    public String getPlotMePath() {
+        return new File(".").getAbsolutePath() + File.separator + "plugins" + File.separator + this.plugin + File.separator;
+    }
+
+    public String getAthionPlotsPath() {
+        return new File(".").getAbsolutePath() + File.separator + "plugins" + File.separator + this.plugin + File.separator;
+    }
+
+    public FileConfiguration getPlotMeConfig(String dataFolder) {
+        File plotMeFile = new File(dataFolder + "config.yml");
+        if (!plotMeFile.exists()) {
+            return null;
+        }
+        return YamlConfiguration.loadConfiguration(plotMeFile);
+    }
+
+    public Set<String> getPlotMeWorlds(FileConfiguration plotConfig) {
+        return plotConfig.getConfigurationSection("worlds").getKeys(false);
+    }
+
+    public void mergeWorldYml(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(String plugin, String location) {
+        try {
+            Path path = Paths.get(location);
+            File file = new File(location);
+            if (!file.exists()) {
+                return;
+            }
+            String content = new String(Files.readAllBytes(path), StandardCharsets.UTF_8);
+            content = content.replaceAll("PlotMe-DefaultGenerator", "PlotSquared");
+            content = content.replaceAll(plugin, "PlotSquared");
+            Files.write(path, content.getBytes(StandardCharsets.UTF_8));
+        } catch (IOException ignored) {
+            //ignored
+        }
+    }
+
+    public boolean run(APlotMeConnector connector) {
+        try {
+            String dataFolder = getPlotMePath();
+            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());
+
+            Connection connection = connector.getPlotMeConnection(this.plugin, plotConfig, dataFolder);
+
+            if (!connector.isValidConnection(connection)) {
+                sendMessage("Cannot connect to PlotMe DB. Conversion process will not continue");
+                return false;
+            }
+
+            sendMessage(this.plugin + " conversion has started. To disable this, please set 'plotme-convert.enabled' to false in the 'settings.yml'");
+
+            mergeWorldYml(this.plugin, plotConfig);
+
+            sendMessage("Connecting to " + this.plugin + " DB");
+
+            ArrayList<Plot> createdPlots = new ArrayList<>();
+
+            sendMessage("Collecting plot data");
+
+            String dbPrefix = this.plugin.toLowerCase();
+            sendMessage(" - " + dbPrefix + "Plots");
+            final Set<String> worlds = getPlotMeWorlds(plotConfig);
+
+            if (Settings.CONVERT_PLOTME) {
+                sendMessage("Updating bukkit.yml");
+                updateWorldYml(this.plugin, "bukkit.yml");
+                updateWorldYml(this.plugin, "plugins/Multiverse-Core/worlds.yml");
+                for (String world : plotConfig.getConfigurationSection("worlds").getKeys(false)) {
+                    sendMessage("Copying config for: " + world);
+                    try {
+                        String actualWorldName = getWorld(world);
+                        connector.copyConfig(plotConfig, world, actualWorldName);
+                        PS.get().config.save(PS.get().configFile);
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                        sendMessage("&c-- &lFailed to save configuration for world '" + world
+                                + "'\nThis will need to be done using the setup command, or manually");
+                    }
+                }
+            }
+            HashMap<String, HashMap<PlotId, Plot>> plots = connector.getPlotMePlots(connection);
+            int plotCount = 0;
+            for (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");
+            File plotmeDgFile = new File(dataFolder + File.separator + "PlotMe-DefaultGenerator" + File.separator + "config.yml");
+            if (plotmeDgFile.exists()) {
+                YamlConfiguration plotmeDgYml = YamlConfiguration.loadConfiguration(plotmeDgFile);
+                try {
+                    for (String world : plots.keySet()) {
+                        String actualWorldName = getWorld(world);
+                        String plotMeWorldName = world.toLowerCase();
+                        Integer pathwidth = plotmeDgYml.getInt("worlds." + plotMeWorldName + ".PathWidth"); //
+                        /*
+                         * TODO: dead code
+                         * 
+                        if (pathwidth == null) {
+                            pathwidth = 7;
+                        }
+                        */
+                        PS.get().config.set("worlds." + world + ".road.width", pathwidth);
+
+                        Integer pathheight = plotmeDgYml.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 = plotmeDgYml.getInt("worlds." + plotMeWorldName + ".PlotSize"); //
+                        if (plotSize == 0) {
+                            plotSize = 32;
+                        }
+                        PS.get().config.set("worlds." + world + ".plot.size", plotSize);
+                        String wallblock = plotmeDgYml.getString("worlds." + plotMeWorldName + ".WallBlock", "44"); //
+                        PS.get().config.set("worlds." + world + ".wall.block", wallblock);
+                        String floor = plotmeDgYml.getString("worlds." + plotMeWorldName + ".PlotFloorBlock", "2"); //
+                        PS.get().config.set("worlds." + world + ".plot.floor", Collections.singletonList(floor));
+                        String filling = plotmeDgYml.getString("worlds." + plotMeWorldName + ".FillBlock", "3"); //
+                        PS.get().config.set("worlds." + world + ".plot.filling", Collections.singletonList(filling));
+                        String road = plotmeDgYml.getString("worlds." + plotMeWorldName + ".RoadMainBlock", "5");
+                        PS.get().config.set("worlds." + world + ".road.block", road);
+                        Integer height = plotmeDgYml.getInt("worlds." + plotMeWorldName + ".RoadHeight"); //
+                        if (height == 0) {
+                            height = plotmeDgYml.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 ignored) {
+                    //ignored
+                }
+            }
+            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 (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 (String worldName : worlds) {
+                            World world = Bukkit.getWorld(getWorld(worldName));
+                            if (world == null) {
+                                sendMessage("&cInvalid world in PlotMe configuration: " + worldName);
+                            }
+                            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 (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 (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);
+                                World myWorld = WorldCreator.name(actualWorldName).generator(new BukkitPlotGenerator(new HybridGen())).createWorld();
+                                myWorld.save();
+                            }
+                        }
+                    } catch (CommandException 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 (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,5 +1,17 @@
 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;
@@ -10,19 +22,8 @@ import java.util.HashMap;
 import java.util.Map.Entry;
 import java.util.UUID;
 
-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.PlotId;
-import com.intellectualcrafters.plot.object.StringWrapper;
-import com.intellectualcrafters.plot.util.MainUtil;
-import com.intellectualcrafters.plot.util.UUIDHandler;
-
 public class PlotMeConnector_017 extends APlotMeConnector {
+
     private String plugin;
 
     @Override
@@ -41,42 +42,51 @@ public class PlotMeConnector_017 extends APlotMeConnector {
                 }
                 return new SQLite(dataFolder + File.separator + "plots.db").openConnection();
             }
+        } catch (SQLException | ClassNotFoundException ignored) {
+            //ignored
+            ignored.printStackTrace();
         }
-        catch (SQLException | ClassNotFoundException e) {}
         return null;
     }
 
     @Override
     public HashMap<String, HashMap<PlotId, Plot>> getPlotMePlots(Connection connection) throws SQLException {
-        ResultSet r;
-        PreparedStatement stmt;
+        ResultSet resultSet;
+        PreparedStatement statement;
         HashMap<String, Integer> plotWidth = new HashMap<>();
         HashMap<String, Integer> roadWidth = new HashMap<>();
-        final HashMap<Integer, Plot> plots = new HashMap<>();
+        HashMap<Integer, Plot> plots = new HashMap<>();
         HashMap<String, HashMap<PlotId, boolean[]>> merges = new HashMap<>();
-        stmt = connection.prepareStatement("SELECT * FROM `" + plugin + "core_plots`");
-        r = stmt.executeQuery();
-        boolean checkUUID = DBFunc.hasColumn(r, "ownerID");
-        boolean merge = !plugin.equals("plotme") && Settings.CONVERT_PLOTME;
-        while (r.next()) {
-            int key = r.getInt("plot_id");
-            PlotId id = new PlotId(r.getInt("plotX"), r.getInt("plotZ"));
-            String name = r.getString("owner");
-            String world = LikePlotMeConverter.getWorld(r.getString("world"));
-            if (!plots.containsKey(world)) {
-                if (merge) {
-                    int plot = PS.get().config.getInt("worlds." + world + ".plot.size");
-                    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[]>());
-                }
+        try {
+            statement = connection.prepareStatement("SELECT * FROM `" + this.plugin + "core_plots`");
+            resultSet = statement.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;
+        }
+        boolean checkUUID = DBFunc.hasColumn(resultSet, "ownerID");
+        boolean merge = !this.plugin.equals("plotme") && Settings.CONVERT_PLOTME;
+        while (resultSet.next()) {
+            int key = resultSet.getInt("plot_id");
+            PlotId id = new PlotId(resultSet.getInt("plotX"), resultSet.getInt("plotZ"));
+            String name = resultSet.getString("owner");
+            String world = LikePlotMeConverter.getWorld(resultSet.getString("world"));
+            if (!plots.containsKey(world) && merge) {
+                int plot = PS.get().config.getInt("worlds." + world + ".plot.size");
+                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) {
-                int tx = r.getInt("topX");
-                int tz = r.getInt("topZ");
-                int bx = r.getInt("bottomX") - 1;
-                int bz = r.getInt("bottomZ") - 1;
+                int tx = resultSet.getInt("topX");
+                int tz = resultSet.getInt("topZ");
+                int bx = resultSet.getInt("bottomX") - 1;
+                int bz = resultSet.getInt("bottomZ") - 1;
                 int path = roadWidth.get(world);
                 int plot = plotWidth.get(world);
                 Location top = getPlotTopLocAbs(path, plot, id);
@@ -98,94 +108,88 @@ public class PlotMeConnector_017 extends APlotMeConnector {
             if (owner == null) {
                 if (name.equals("*")) {
                     owner = DBFunc.everyone;
-                }
-                else {
-                    if (checkUUID){
+                } else {
+                    if (checkUUID) {
                         try {
-                            byte[] bytes = r.getBytes("ownerid");
+                            byte[] bytes = resultSet.getBytes("ownerid");
                             if (bytes != null) {
                                 owner = UUID.nameUUIDFromBytes(bytes);
-                                if (owner != null) {
-                                    UUIDHandler.add(new StringWrapper(name), owner);
-                                }
+                                UUIDHandler.add(new StringWrapper(name), owner);
                             }
-                        }
-                        catch (Exception e) {
+                        } catch (Exception e) {
                             e.printStackTrace();
                         }
                     }
                     if (owner == null) {
-                        MainUtil.sendConsoleMessage("&cCould not identify owner for plot: " + id + " -> '" + name + "'");
+                        PS.log("&cCould not identify owner for plot: " + id + " -> '" + name + "'");
                         continue;
                     }
                 }
-            }
-            else {
+            } else {
                 UUIDHandler.add(new StringWrapper(name), owner);
             }
-            Plot plot = new Plot(world, id, owner);
+            Plot plot = new Plot(PlotArea.createGeneric(world), id, owner);
             plots.put(key, plot);
         }
         for (Entry<Integer, Plot> entry : plots.entrySet()) {
             Plot plot = entry.getValue();
-            HashMap<PlotId, boolean[]> mergeMap = merges.get(plot.world);
+            HashMap<PlotId, boolean[]> mergeMap = merges.get(plot.getArea().worldname);
             if (mergeMap != null) {
-                if (mergeMap.containsKey(plot.id)) {
-                    plot.getSettings().setMerged(mergeMap.get(plot.id));
+                if (mergeMap.containsKey(plot.getId())) {
+                    plot.setMerged(mergeMap.get(plot.getId()));
                 }
             }
         }
-        r.close();
-        stmt.close();
+        resultSet.close();
+        statement.close();
         try {
-            MainUtil.sendConsoleMessage(" - " + plugin + "core_denied");
-            stmt = connection.prepareStatement("SELECT * FROM `" + plugin + "core_denied`");
-            r = stmt.executeQuery();
-            
-            while (r.next()) {
-                int key = r.getInt("plot_id");
+            PS.log(" - " + this.plugin + "core_denied");
+            statement = connection.prepareStatement("SELECT * FROM `" + this.plugin + "core_denied`");
+            resultSet = statement.executeQuery();
+
+            while (resultSet.next()) {
+                int key = resultSet.getInt("plot_id");
                 Plot plot = plots.get(key);
                 if (plot == null) {
-                    MainUtil.sendConsoleMessage("&6Denied (" + key + ") references deleted plot; ignoring entry.");
+                    PS.log("&6Denied (" + key + ") references deleted plot; ignoring entry.");
                     continue;
                 }
-                UUID denied = UUID.fromString(r.getString("player"));
+                UUID denied = UUID.fromString(resultSet.getString("player"));
                 plot.getDenied().add(denied);
             }
-            
-            MainUtil.sendConsoleMessage(" - " + plugin + "core_allowed");
-            stmt = connection.prepareStatement("SELECT * FROM `" + plugin + "core_allowed`");
-            r = stmt.executeQuery();
-            
-            while (r.next()) {
-                int key = r.getInt("plot_id");
+
+            PS.log(" - " + this.plugin + "core_allowed");
+            statement = connection.prepareStatement("SELECT * FROM `" + this.plugin + "core_allowed`");
+            resultSet = statement.executeQuery();
+
+            while (resultSet.next()) {
+                int key = resultSet.getInt("plot_id");
                 Plot plot = plots.get(key);
                 if (plot == null) {
-                    MainUtil.sendConsoleMessage("&6Allowed (" + key + ") references deleted plot; ignoring entry.");
+                    PS.log("&6Allowed (" + key + ") references deleted plot; ignoring entry.");
                     continue;
                 }
-                UUID allowed = UUID.fromString(r.getString("player"));
+                UUID allowed = UUID.fromString(resultSet.getString("player"));
                 plot.getTrusted().add(allowed);
             }
-            r.close();
-            stmt.close();
-        
-        }
-        catch (Exception e) {
+            resultSet.close();
+            statement.close();
+
+        } catch (SQLException e) {
             e.printStackTrace();
         }
         HashMap<String, HashMap<PlotId, Plot>> processed = new HashMap<>();
-        
+
         for (Entry<Integer, Plot> entry : plots.entrySet()) {
             Plot plot = entry.getValue();
-            HashMap<PlotId, Plot> map = processed.get(plot.world);
+            HashMap<PlotId, Plot> map = processed.get(plot.getArea().worldname);
             if (map == null) {
                 map = new HashMap<>();
-                processed.put(plot.world, map);
+                processed.put(plot.getArea().worldname, map);
             }
-            map.put(plot.id, plot);
+            map.put(plot.getId(), plot);
         }
-        return processed ;
+        return processed;
     }
 
     @Override

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

@@ -0,0 +1,66 @@
+package com.plotsquared.bukkit.events;
+
+import com.intellectualcrafters.plot.flag.Flag;
+import com.intellectualcrafters.plot.object.PlotCluster;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Called when a flag is removed from a plot.
+ */
+public class ClusterFlagRemoveEvent extends Event implements Cancellable {
+
+    private static final 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(Flag flag, PlotCluster cluster) {
+        this.cluster = cluster;
+        this.flag = flag;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Get the cluster involved.
+     *
+     * @return PlotCluster
+     */
+    public PlotCluster getCluster() {
+        return this.cluster;
+    }
+
+    /**
+     * Get the flag involved.
+     *
+     * @return Flag
+     */
+    public Flag getFlag() {
+        return this.flag;
+    }
+
+    @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/plotsquared/bukkit/events/PlayerClaimPlotEvent.java

@@ -0,0 +1,62 @@
+package com.plotsquared.bukkit.events;
+
+import com.intellectualcrafters.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/plotsquared/bukkit/events/PlayerEnterPlotEvent.java

@@ -0,0 +1,41 @@
+package com.plotsquared.bukkit.events;
+
+import com.intellectualcrafters.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/plotsquared/bukkit/events/PlayerLeavePlotEvent.java

@@ -0,0 +1,45 @@
+package com.plotsquared.bukkit.events;
+
+import com.intellectualcrafters.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/plotsquared/bukkit/events/PlayerPlotDeniedEvent.java

@@ -0,0 +1,66 @@
+package com.plotsquared.bukkit.events;
+
+import com.intellectualcrafters.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/plotsquared/bukkit/events/PlayerPlotHelperEvent.java

@@ -0,0 +1,70 @@
+package com.plotsquared.bukkit.events;
+
+import com.intellectualcrafters.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/plotsquared/bukkit/events/PlayerPlotTrustedEvent.java

@@ -0,0 +1,70 @@
+package com.plotsquared.bukkit.events;
+
+import com.intellectualcrafters.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/plotsquared/bukkit/events/PlayerTeleportToPlotEvent.java

@@ -0,0 +1,72 @@
+package com.plotsquared.bukkit.events;
+
+import com.intellectualcrafters.plot.object.Location;
+import com.intellectualcrafters.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/plotsquared/bukkit/events/PlotClearEvent.java

@@ -0,0 +1,56 @@
+package com.plotsquared.bukkit.events;
+
+import com.intellectualcrafters.plot.object.Plot;
+import com.intellectualcrafters.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().getArea().worldname;
+    }
+
+    @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/plotsquared/bukkit/events/PlotDeleteEvent.java

@@ -0,0 +1,45 @@
+package com.plotsquared.bukkit.events;
+
+import com.intellectualcrafters.plot.object.Plot;
+import com.intellectualcrafters.plot.object.PlotId;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Called when a plot is deleted
+ *
+ */
+public class PlotDeleteEvent extends PlotEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+
+    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().getArea().worldname;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+}

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

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

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

@@ -0,0 +1,56 @@
+package com.plotsquared.bukkit.events;
+
+import com.intellectualcrafters.plot.flag.Flag;
+import com.intellectualcrafters.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/plotsquared/bukkit/events/PlotFlagRemoveEvent.java

@@ -0,0 +1,56 @@
+package com.plotsquared.bukkit.events;
+
+import com.intellectualcrafters.plot.flag.Flag;
+import com.intellectualcrafters.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/plotsquared/bukkit/events/PlotMergeEvent.java

@@ -0,0 +1,62 @@
+package com.plotsquared.bukkit.events;
+
+import com.intellectualcrafters.plot.object.Plot;
+import com.intellectualcrafters.plot.object.PlotId;
+import org.bukkit.World;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+
+import java.util.ArrayList;
+
+public class PlotMergeEvent extends PlotEvent implements Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final ArrayList<PlotId> plots;
+    private final World world;
+    private boolean cancelled;
+
+    /**
+     * PlotMergeEvent: Called when plots are merged
+     *
+     * @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 PlotMergeEvent(World world, Plot plot, ArrayList<PlotId> plots) {
+        super(plot);
+        this.world = world;
+        this.plots = plots;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Get the plots being added.
+     *
+     * @return Plot
+     */
+    public ArrayList<PlotId> getPlots() {
+        return this.plots;
+    }
+
+    public World getWorld() {
+        return this.world;
+    }
+
+    @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/plotsquared/bukkit/events/PlotRateEvent.java

@@ -1,47 +1,41 @@
-package com.plotsquared.bukkit.events;
-
-import org.bukkit.event.HandlerList;
-
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotPlayer;
-import com.intellectualcrafters.plot.object.Rating;
-
-/**
- * Created 2015-07-13 for PlotSquaredGit
- *
- * @author Citymonstret
- */
-public class PlotRateEvent extends PlotEvent {
-
-    private static HandlerList handlers = new HandlerList();
-    private final PlotPlayer rater;
-    private Rating rating;
-
-    public PlotRateEvent(final PlotPlayer rater, final Rating rating, final Plot plot) {
-        super(plot);
-        this.rater = rater;
-        this.rating = rating;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    public PlotPlayer getRater() {
-        return this.rater;
-    }
-
-    public void setRating(Rating rating) {
-        this.rating = rating;
-    }
-
-    public Rating getRating() {
-        return this.rating;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-
-}
+package com.plotsquared.bukkit.events;
+
+import com.intellectualcrafters.plot.object.Plot;
+import com.intellectualcrafters.plot.object.PlotPlayer;
+import com.intellectualcrafters.plot.object.Rating;
+import org.bukkit.event.HandlerList;
+
+public class PlotRateEvent extends PlotEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final PlotPlayer rater;
+    private Rating rating;
+
+    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;
+    }
+
+}

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

@@ -0,0 +1,67 @@
+package com.plotsquared.bukkit.events;
+
+import com.intellectualcrafters.plot.object.PlotArea;
+import com.intellectualcrafters.plot.object.PlotId;
+import org.bukkit.World;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+import java.util.ArrayList;
+
+public class PlotUnlinkEvent extends Event implements Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final ArrayList<PlotId> plots;
+    private final World world;
+    private final PlotArea area;
+    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(World world, PlotArea area, ArrayList<PlotId> plots) {
+        this.plots = plots;
+        this.world = world;
+        this.area = area;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Get the plots involved.
+     *
+     * @return The {@link PlotId}'s of the plots involved
+     */
+    public ArrayList<PlotId> getPlots() {
+        return this.plots;
+    }
+
+    public World getWorld() {
+        return this.world;
+    }
+
+    public PlotArea getArea() {
+        return this.area;
+    }
+
+    @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/plotsquared/bukkit/generator/BukkitAugmentedGenerator.java

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

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

@@ -0,0 +1,327 @@
+package com.plotsquared.bukkit.generator;
+
+import com.intellectualcrafters.plot.PS;
+import com.intellectualcrafters.plot.generator.GeneratorWrapper;
+import com.intellectualcrafters.plot.generator.HybridGen;
+import com.intellectualcrafters.plot.generator.IndependentPlotGenerator;
+import com.intellectualcrafters.plot.object.PlotArea;
+import com.intellectualcrafters.plot.object.PlotId;
+import com.intellectualcrafters.plot.object.PlotManager;
+import com.intellectualcrafters.plot.object.PseudoRandom;
+import com.intellectualcrafters.plot.object.SetupObject;
+import com.intellectualcrafters.plot.util.ChunkManager;
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.PlotChunk;
+import com.intellectualcrafters.plot.util.SetQueue;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.bukkit.util.block.GenChunk;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.generator.BlockPopulator;
+import org.bukkit.generator.ChunkGenerator;
+
+public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrapper<ChunkGenerator> {
+    
+    private final PlotChunk<Chunk> chunkSetter;
+    private final PseudoRandom random = new PseudoRandom();
+    private final IndependentPlotGenerator plotGenerator;
+    private final List<BlockPopulator> populators = new ArrayList<>();
+    private final ChunkGenerator platformGenerator;
+    private final boolean full;
+    private boolean loaded = false;
+
+    public BukkitPlotGenerator(IndependentPlotGenerator generator) {
+        this.plotGenerator = generator;
+        this.platformGenerator = this;
+        this.populators.add(new BlockPopulator() {
+            @Override
+            public void populate(World world, Random r, Chunk c) {
+                GenChunk result = (GenChunk) BukkitPlotGenerator.this.chunkSetter;
+                if (result.result_data != null) {
+                    for (int i = 0; i < result.result_data.length; i++) {
+                        byte[] section = result.result_data[i];
+                        if (section == null) {
+                            continue;
+                        }
+                        for (int j = 0; j < section.length; j++) {
+                            int x = MainUtil.x_loc[i][j];
+                            int y = MainUtil.y_loc[i][j];
+                            int z = MainUtil.z_loc[i][j];
+                            c.getBlock(x, y, z).setData(section[j]);
+                        }
+                    }
+                }
+                random.state = c.getX() << 16 | c.getZ() & 0xFFFF;
+                PlotArea area = PS.get().getPlotArea(world.getName(), null);
+                SetQueue.ChunkWrapper wrap = SetQueue.IMP.new ChunkWrapper(area.worldname, c.getX(), c.getZ());
+                PlotChunk<?> chunk = SetQueue.IMP.queue.getChunk(wrap);
+                if (plotGenerator.populateChunk(chunk, area, random)) {
+                    chunk.addToQueue();
+                }
+            }
+        });
+        this.chunkSetter = new GenChunk(null, null);
+        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;
+        PS.debug("BukkitPlotGenerator does not fully support: " + cg);
+        this.platformGenerator = cg;
+        this.plotGenerator = new IndependentPlotGenerator() {
+            @Override
+            public void processSetup(SetupObject setup) {}
+            
+            @Override
+            public void initialize(PlotArea area) {}
+            
+            @Override
+            public PlotManager getNewPlotManager() {
+                return new HybridGen().getNewPlotManager();
+            }
+            
+            @Override
+            public String getName() {
+                return cg.getClass().getName();
+            }
+            
+            @Override
+            public PlotArea getNewPlotArea(String world, String id, PlotId min, PlotId max) {
+                return new HybridGen().getNewPlotArea(world, id, min, max);
+            }
+            
+            @Override
+            public void generateChunk(final PlotChunk<?> result, PlotArea settings, PseudoRandom random) {
+                World w = BukkitUtil.getWorld(world);
+                Random r = new Random(result.getChunkWrapper().hashCode());
+                BiomeGrid grid = new BiomeGrid() {
+                    @Override
+                    public void setBiome(int x, int z, Biome biome) {
+                        result.setBiome(x, z, biome.ordinal());
+                    }
+                    
+                    @Override
+                    public Biome getBiome(int arg0, int arg1) {
+                        return Biome.FOREST;
+                    }
+                };
+                try {
+                    // ChunkData will spill a bit
+                    ChunkData data = cg.generateChunkData(w, r, result.getX(), result.getZ(), grid);
+                    if (data != null) {
+                        return;
+                    }
+                } catch (Throwable e) {
+                    //ignored
+                }
+                // Populator spillage
+                short[][] tmp = cg.generateExtBlockSections(w, r, result.getX(), result.getZ(), grid);
+                if (tmp != null) {
+                    for (int i = 0; i < tmp.length; i++) {
+                        short[] section = tmp[i];
+                        if (section == null) {
+                            if (i < 7) {
+                                for (int x = 0; x < 16; x++) {
+                                    for (int z = 0; z < 16; z++) {
+                                        for (int y = i << 4; y < (i << 4) + 16; y++) {
+                                            result.setBlock(x, y, z, (short) 0, (byte) 0);
+                                        }
+                                    }
+                                }
+                            }
+                            continue;
+                        }
+                        for (int j = 0; j < section.length; j++) {
+                            int x = MainUtil.x_loc[i][j];
+                            int y = MainUtil.y_loc[i][j];
+                            int z = MainUtil.z_loc[i][j];
+                            result.setBlock(x, y, z, section[j], (byte) 0);
+                        }
+                    }
+                }
+                for (BlockPopulator populator : cg.getDefaultPopulators(w)) {
+                    populator.populate(w, r, (Chunk) result.getChunk());
+                }
+            }
+        };
+        this.chunkSetter = new GenChunk(null, SetQueue.IMP.new ChunkWrapper(world, 0, 0));
+        if (cg != null) {
+            this.populators.addAll(cg.getDefaultPopulators(BukkitUtil.getWorld(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
+    public List<BlockPopulator> getDefaultPopulators(World world) {
+        try {
+            if (!this.loaded) {
+                String name = world.getName();
+                PS.get().loadWorld(name, this);
+                Set<PlotArea> areas = PS.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();
+        }
+        if (world == null) {
+            return populators;
+        }
+        ArrayList<BlockPopulator> toAdd = new ArrayList<BlockPopulator>();
+        List<BlockPopulator> existing = world.getPopulators();
+        for (BlockPopulator populator : populators) {
+            if (!existing.contains(populator)) {
+                toAdd.add(populator);
+            }
+        }
+        return toAdd;
+    }
+
+    @Override
+    public ChunkData generateChunkData(World world, Random random, int cx, int cz, BiomeGrid grid) {
+        GenChunk result = (GenChunk) this.chunkSetter;
+        // Set the chunk location
+        result.setChunkWrapper(SetQueue.IMP.new ChunkWrapper(world.getName(), cx, cz));
+        // Set the result data
+        result.cd = createChunkData(world);
+        result.grid = grid;
+        result.result = null;
+        result.result_data = 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, cx, cz, grid);
+            } else {
+                generate(world, cx, cz, result);
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+        // Return the result data
+        return result.cd;
+    }
+    
+    public void generate(World world, int cx, int cz, GenChunk result) {
+        // Load if improperly loaded
+        if (!this.loaded) {
+            String name = world.getName();
+            PS.get().loadWorld(name, this);
+            this.loaded = true;
+        }
+        // Set random seed
+        this.random.state = cx << 16 | cz & 0xFFFF;
+        // Process the chunk
+        if (ChunkManager.preProcessChunk(result)) {
+            return;
+        }
+        PlotArea area = PS.get().getPlotArea(world.getName(), null);
+        this.plotGenerator.generateChunk(this.chunkSetter, area, this.random);
+        ChunkManager.postProcessChunk(result);
+    }
+    
+    @Override
+    public short[][] generateExtBlockSections(World world, Random r, int cx, int cz, BiomeGrid grid) {
+        GenChunk result = (GenChunk) this.chunkSetter;
+        // Set the chunk location
+        result.setChunkWrapper(SetQueue.IMP.new ChunkWrapper(world.getName(), cx, cz));
+        // Set the result data
+        result.result = new short[16][];
+        result.result_data = new byte[16][];
+        result.grid = grid;
+        result.cd = null;
+        // Catch any exceptions (as exceptions usually thrown)
+        try {
+            // Fill the result data
+            if (this.platformGenerator != this) {
+                return this.platformGenerator.generateExtBlockSections(world, r, cx, cz, grid);
+            } else {
+                generate(world, cx, cz, result);
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+        // Return the result data
+        return result.result;
+    }
+    
+    /**
+     * Allow spawning everywhere.
+     * @param world Ignored
+     * @param x Ignored
+     * @param z Ignored
+     * @return always true
+     */
+    @Override
+    public boolean canSpawn(World world, int x, int z) {
+        return true;
+    }
+    
+    @Override
+    public String toString() {
+        if (this.platformGenerator == this) {
+            return "" + this.plotGenerator;
+        }
+        if (this.platformGenerator == null) {
+            return "null";
+        } else {
+            return this.platformGenerator.getClass().getName();
+        }
+    }
+    
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        return toString().equals(obj.toString()) || toString().equals(obj.getClass().getName());
+    }
+}

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

@@ -0,0 +1,326 @@
+package com.plotsquared.bukkit.listeners;
+
+import static com.intellectualcrafters.plot.util.ReflectionUtils.getRefClass;
+
+import com.intellectualcrafters.plot.PS;
+import com.intellectualcrafters.plot.config.Settings;
+import com.intellectualcrafters.plot.object.ChunkLoc;
+import com.intellectualcrafters.plot.object.Location;
+import com.intellectualcrafters.plot.object.Plot;
+import com.intellectualcrafters.plot.object.PlotPlayer;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefClass;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefField;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefMethod;
+import com.intellectualcrafters.plot.util.TaskManager;
+import com.intellectualcrafters.plot.util.UUIDHandler;
+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.util.ArrayDeque;
+import java.util.HashMap;
+import java.util.Map.Entry;
+
+public class ChunkListener implements Listener {
+
+    private RefMethod methodGetHandleChunk;
+    private RefField mustSave;
+    private Chunk lastChunk;
+
+    
+    public ChunkListener() {
+        if (Settings.CHUNK_PROCESSOR_GC || Settings.CHUNK_PROCESSOR_TRIM_ON_SAVE) {
+            try {
+                RefClass classChunk = getRefClass("{nms}.Chunk");
+                RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
+                this.mustSave = classChunk.getField("mustSave");
+                this.methodGetHandleChunk = classCraftChunk.getMethod("getHandle");
+            } catch (Throwable e) {
+                PS.debug("PlotSquared/Server not compatible for chunk processor trim/gc");
+                Settings.CHUNK_PROCESSOR_GC = false;
+                Settings.CHUNK_PROCESSOR_TRIM_ON_SAVE = false;
+            }
+        }
+        if (!Settings.CHUNK_PROCESSOR_GC) {
+            return;
+        }
+        TaskManager.runTask(new Runnable() {
+            @Override
+            public void run() {
+                int distance = Bukkit.getViewDistance() + 2;
+                HashMap<String, HashMap<ChunkLoc, Integer>> players = new HashMap<>();
+                for (Entry<String, PlotPlayer> entry : UUIDHandler.getPlayers().entrySet()) {
+                    PlotPlayer pp = entry.getValue();
+                    Location location = pp.getLocation();
+                    String world = location.getWorld();
+                    if (!PS.get().hasPlotArea(world)) {
+                        continue;
+                    }
+                    HashMap<ChunkLoc, Integer> map = players.get(world);
+                    if (map == null) {
+                        map = new HashMap<>();
+                        players.put(world, map);
+                    }
+                    ChunkLoc origin = new ChunkLoc(location.getX() >> 4, location.getZ() >> 4);
+                    Integer val = map.get(origin);
+                    int check;
+                    if (val != null) {
+                        if (val == distance) {
+                            continue;
+                        }
+                        check = distance - val;
+                    } else {
+                        check = distance;
+                        map.put(origin, distance);
+                    }
+                    for (int x = -distance; x <= distance; x++) {
+                        if (x >= check || -x >= check) {
+                            continue;
+                        }
+                        for (int z = -distance; z <= distance; z++) {
+                            if (z >= check || -z >= check) {
+                                continue;
+                            }
+                            int weight = distance - Math.max(Math.abs(x), Math.abs(z));
+                            ChunkLoc chunk = new ChunkLoc(x + origin.x, z + origin.z);
+                            val = map.get(chunk);
+                            if (val == null || val < weight) {
+                                map.put(chunk, weight);
+                            }
+
+                        }
+                    }
+                }
+                int time = 300;
+                for (World world : Bukkit.getWorlds()) {
+                    String name = world.getName();
+                    if (!PS.get().hasPlotArea(name)) {
+                        continue;
+                    }
+                    boolean autoSave = world.isAutoSave();
+                    if (autoSave) {
+                        world.setAutoSave(false);
+                    }
+                    HashMap<ChunkLoc, Integer> map = players.get(name);
+                    if (map == null || map.isEmpty()) {
+                        continue;
+                    }
+                    Chunk[] chunks = world.getLoadedChunks();
+                    ArrayDeque<Chunk> toUnload = new ArrayDeque<>();
+                    for (Chunk chunk : chunks) {
+                        int x = chunk.getX();
+                        int z = chunk.getZ();
+                        if (!map.containsKey(new ChunkLoc(x, z))) {
+                            toUnload.add(chunk);
+                        }
+                    }
+                    if (!toUnload.isEmpty()) {
+                        long start = System.currentTimeMillis();
+                        Chunk chunk;
+                        while ((chunk = toUnload.poll()) != null && System.currentTimeMillis() - start < 5) {
+                            if (!Settings.CHUNK_PROCESSOR_TRIM_ON_SAVE || !unloadChunk(name, chunk)) {
+                                if (chunk.isLoaded()) {
+                                    chunk.unload(true, false);
+                                }
+                            }
+                        }
+                        if (!toUnload.isEmpty()) {
+                            time = 1;
+                        }
+                    }
+                    if (!Settings.CHUNK_PROCESSOR_TRIM_ON_SAVE && autoSave) {
+                        world.setAutoSave(true);
+                    }
+                }
+                TaskManager.runTaskLater(this, time);
+            }
+        });
+    }
+
+    public boolean unloadChunk(String world, Chunk chunk) {
+        int X = chunk.getX();
+        int Z = chunk.getZ();
+        int x = X << 4;
+        int z = Z << 4;
+        int x2 = x + 15;
+        int z2 = z + 15;
+        Plot plot = new Location(world, x, 1, z).getOwnedPlotAbs();
+        if (plot != null && plot.hasOwner()) {
+            return false;
+        }
+        plot = new Location(world, x2, 1, z2).getOwnedPlotAbs();
+        if (plot != null && plot.hasOwner()) {
+            return false;
+        }
+        plot = new Location(world, x2, 1, z).getOwnedPlotAbs();
+        if (plot != null && plot.hasOwner()) {
+            return false;
+        }
+        plot = new Location(world, x, 1, z2).getOwnedPlotAbs();
+        if (plot != null && plot.hasOwner()) {
+            return false;
+        }
+        plot = new Location(world, x + 7, 1, z + 7).getOwnedPlotAbs();
+        if (plot != null && plot.hasOwner()) {
+            return false;
+        }
+        Object c = this.methodGetHandleChunk.of(chunk).call();
+        this.mustSave.of(c).set(false);
+        if (chunk.isLoaded()) {
+            chunk.unload(false, false);
+        }
+        return true;
+    }
+    
+    @EventHandler
+    public void onChunkUnload(ChunkUnloadEvent event) {
+        if (Settings.CHUNK_PROCESSOR_TRIM_ON_SAVE) {
+            Chunk chunk = event.getChunk();
+            String world = chunk.getWorld().getName();
+            if (PS.get().hasPlotArea(world)) {
+                if (unloadChunk(world, chunk)) {
+                    return;
+                }
+            }
+        }
+        if (processChunk(event.getChunk(), true)) {
+            event.setCancelled(true);
+        }
+    }
+    
+    @EventHandler
+    public void onChunkLoad(ChunkLoadEvent event) {
+        processChunk(event.getChunk(), false);
+    }
+    
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onItemSpawn(ItemSpawnEvent event) {
+        Item entity = event.getEntity();
+        Chunk chunk = entity.getLocation().getChunk();
+        if (chunk == this.lastChunk) {
+            event.getEntity().remove();
+            event.setCancelled(true);
+            return;
+        }
+        if (!PS.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();
+        Chunk chunk = entity.getLocation().getChunk();
+        if (chunk == this.lastChunk) {
+            event.getEntity().remove();
+            event.setCancelled(true);
+            return;
+        }
+        if (!PS.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(new Runnable() {
+            @Override
+            public void run() {
+                if (!chunk.isLoaded()) {
+                    Bukkit.getScheduler().cancelTask(TaskManager.tasks.get(currentIndex));
+                    TaskManager.tasks.remove(currentIndex);
+                    PS.debug("[PlotSquared] &aSuccessfully processed and unloaded chunk!");
+                    chunk.unload(true, true);
+                    return;
+                }
+                BlockState[] tiles = chunk.getTileEntities();
+                if (tiles.length == 0) {
+                    Bukkit.getScheduler().cancelTask(TaskManager.tasks.get(currentIndex));
+                    TaskManager.tasks.remove(currentIndex);
+                    PS.debug("[PlotSquared] &aSuccessfully processed and unloaded chunk!");
+                    chunk.unload(true, 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);
+                        PS.debug("[PlotSquared] &aSuccessfully processed and unloaded chunk!");
+                        chunk.unload(true, true);
+                        return;
+                    }
+                    tiles[i].getBlock().setType(Material.AIR, false);
+                    i++;
+                }
+            }
+        }, 5);
+        TaskManager.tasks.put(currentIndex, task);
+    }
+
+    public boolean processChunk(Chunk chunk, boolean unload) {
+        if (!PS.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();
+                }
+            }
+            PS.debug("[PlotSquared] &a detected unsafe chunk and processed: " + (chunk.getX() << 4) + "," + (chunk.getX() << 4));
+        }
+        if (tiles.length > Settings.CHUNK_PROCESSOR_MAX_BLOCKSTATES) {
+            if (unload) {
+                PS.debug("[PlotSquared] &c 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/plotsquared/bukkit/listeners/ForceFieldListener.java

@@ -0,0 +1,105 @@
+package com.plotsquared.bukkit.listeners;
+
+import com.intellectualcrafters.plot.flag.FlagManager;
+import com.intellectualcrafters.plot.object.Location;
+import com.intellectualcrafters.plot.object.Plot;
+import com.intellectualcrafters.plot.object.PlotPlayer;
+import com.plotsquared.bukkit.events.PlayerEnterPlotEvent;
+import com.plotsquared.bukkit.object.BukkitPlayer;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.util.Vector;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+public class ForceFieldListener implements Listener {
+
+    private Set<PlotPlayer> getNearbyPlayers(Player player, Plot plot) {
+        Set<PlotPlayer> players = new HashSet<>();
+        for (Entity entity : player.getNearbyEntities(5d, 5d, 5d)) {
+            PlotPlayer pp;
+            if (!(entity instanceof Player) || ((pp = BukkitUtil.getPlayer((Player) entity)) == null) || !plot.equals(pp.getCurrentPlot())) {
+                continue;
+            }
+            if (!plot.isAdded(pp.getUUID())) {
+                players.add(pp);
+            }
+        }
+        return players;
+    }
+
+    private PlotPlayer hasNearbyPermitted(Player player, Plot plot) {
+        for (Entity entity : player.getNearbyEntities(5d, 5d, 5d)) {
+            PlotPlayer pp;
+            if (!(entity instanceof Player) || ((pp = BukkitUtil.getPlayer((Player) entity)) == null) || !plot.equals(pp.getCurrentPlot())) {
+                continue;
+            }
+            if (plot.isAdded(pp.getUUID())) {
+                return pp;
+            }
+        }
+        return null;
+    }
+
+    public Vector calculateVelocity(PlotPlayer pp, PlotPlayer e) {
+        Location playerLocation = pp.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);
+    }
+
+    @EventHandler
+    public void onPlotEntry(PlayerEnterPlotEvent event) {
+        Player player = event.getPlayer();
+        PlotPlayer pp = BukkitUtil.getPlayer(player);
+        Plot plot = event.getPlot();
+        if (plot == null) {
+            return;
+        }
+        if ((FlagManager.getPlotFlagRaw(plot, "forcefield") != null) && FlagManager.getPlotFlagRaw(plot, "forcefield").getValue().equals("true")) {
+            if (!FlagManager.isBooleanFlag(plot, "forcefield", false)) {
+                UUID uuid = pp.getUUID();
+                if (plot.isAdded(uuid)) {
+                    Set<PlotPlayer> players = getNearbyPlayers(player, plot);
+                    for (PlotPlayer oPlayer : players) {
+                        ((BukkitPlayer) oPlayer).player.setVelocity(calculateVelocity(pp, oPlayer));
+                    }
+                } else {
+                    PlotPlayer oPlayer = hasNearbyPermitted(player, plot);
+                    if (oPlayer == null) {
+                        return;
+                    }
+                    player.setVelocity(calculateVelocity(oPlayer, pp));
+                }
+            }
+        }
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/listeners/PlayerEvents183.java

@@ -0,0 +1,49 @@
+package com.plotsquared.bukkit.listeners;
+
+import com.intellectualcrafters.plot.PS;
+import com.intellectualcrafters.plot.flag.FlagManager;
+import com.intellectualcrafters.plot.object.Location;
+import com.intellectualcrafters.plot.object.Plot;
+import com.intellectualcrafters.plot.object.PlotArea;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import org.bukkit.block.Block;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockExplodeEvent;
+
+import java.util.Iterator;
+
+public class PlayerEvents183 implements Listener {
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onBigBoom(BlockExplodeEvent event) {
+        Block block = event.getBlock();
+        Location loc = BukkitUtil.getLocation(block.getLocation());
+        String world = loc.getWorld();
+        if (!PS.get().hasPlotArea(world)) {
+            return;
+        }
+        PlotArea area = loc.getPlotArea();
+        if (area == null) {
+            Iterator<Block> iterator = event.blockList().iterator();
+            while (iterator.hasNext()) {
+                loc = BukkitUtil.getLocation(iterator.next().getLocation());
+                if (loc.getPlotArea() != null) {
+                    iterator.remove();
+                }
+            }
+            return;
+        }
+        Plot plot = area.getOwnedPlot(loc);
+        if (plot == null || !FlagManager.isPlotFlagTrue(plot, "explosion")) {
+            event.setCancelled(true);
+        }
+        Iterator<Block> iterator = event.blockList().iterator();
+        while (iterator.hasNext()) {
+            Block b = iterator.next();
+            if (!plot.equals(area.getOwnedPlot(BukkitUtil.getLocation(b.getLocation())))) {
+                iterator.remove();
+            }
+        }
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/listeners/PlayerEvents_1_8.java

@@ -1,9 +1,15 @@
 package com.plotsquared.bukkit.listeners;
 
-import java.util.HashSet;
-import java.util.List;
-import java.util.UUID;
-
+import com.intellectualcrafters.plot.PS;
+import com.intellectualcrafters.plot.config.C;
+import com.intellectualcrafters.plot.object.Location;
+import com.intellectualcrafters.plot.object.Plot;
+import com.intellectualcrafters.plot.object.PlotArea;
+import com.intellectualcrafters.plot.object.PlotPlayer;
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.Permissions;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.listener.PlotListener;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockState;
 import org.bukkit.entity.ArmorStand;
@@ -20,31 +26,25 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.PlayerInventory;
 import org.bukkit.inventory.meta.ItemMeta;
 
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.config.C;
-import com.intellectualcrafters.plot.object.Location;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotPlayer;
-import com.intellectualcrafters.plot.util.MainUtil;
-import com.intellectualcrafters.plot.util.Permissions;
-import com.plotsquared.bukkit.util.BukkitUtil;
-import com.plotsquared.listener.PlotListener;
+import java.util.HashSet;
+import java.util.List;
+import java.util.UUID;
 
 public class PlayerEvents_1_8 extends PlotListener implements Listener {
     
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onInventoryClick(InventoryClickEvent event) {
-        if (!event.isLeftClick() || event.getAction() != InventoryAction.PLACE_ALL || event.isShiftClick()) {
+        if (!event.isLeftClick() || (event.getAction() != InventoryAction.PLACE_ALL) || event.isShiftClick()) {
             return;
         }
         HumanEntity entity = event.getWhoClicked();
-        if (!(entity instanceof Player) || !PS.get().isPlotWorld(entity.getWorld().getName())) {
+        if (!(entity instanceof Player) || !PS.get().hasPlotArea(entity.getWorld().getName())) {
             return;
         }
         Player player = (Player) entity;
         PlayerInventory inv = player.getInventory();
         int slot = inv.getHeldItemSlot();
-        if (slot != event.getSlot() || slot > 8 || !event.getEventName().equals("InventoryCreativeEvent")) {
+        if ((slot != event.getSlot()) || (slot > 8) || !event.getEventName().equals("InventoryCreativeEvent")) {
             return;
         }
         ItemStack current = inv.getItemInHand();
@@ -77,82 +77,72 @@ public class PlayerEvents_1_8 extends PlotListener implements Listener {
         if (state.getType() != newItem.getType()) {
             return;
         }
-        final Location l = BukkitUtil.getLocation(state.getLocation());
-        Plot plot = MainUtil.getPlot(l);
+        Location l = BukkitUtil.getLocation(state.getLocation());
+        PlotArea area = l.getPlotArea();
+        if (area == null) {
+            return;
+        }
+        Plot plot = area.getPlotAbs(l);
         PlotPlayer pp = BukkitUtil.getPlayer(player);
         boolean cancelled = false;
         if (plot == null) {
-            if (!MainUtil.isPlotArea(l)) {
-                return;
-            }
             if (!Permissions.hasPermission(pp, "plots.admin.interact.road")) {
                 MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, "plots.admin.interact.road");
                 cancelled = true;
             }
-        }
-        else {
-            if (!plot.hasOwner()) {
-                if (!Permissions.hasPermission(pp, "plots.admin.interact.unowned")) {
-                    MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, "plots.admin.interact.unowned");
-                    cancelled = true;
-                }
+        } else if (!plot.hasOwner()) {
+            if (!Permissions.hasPermission(pp, "plots.admin.interact.unowned")) {
+                MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, "plots.admin.interact.unowned");
+                cancelled = true;
             }
-            else {
-                final UUID uuid = pp.getUUID();
-                if (!plot.isAdded(uuid)) {
-                    if (!Permissions.hasPermission(pp, "plots.admin.interact.other")) {
-                        MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, "plots.admin.interact.other");
-                        cancelled = true;
-                    }
+        } else {
+            UUID uuid = pp.getUUID();
+            if (!plot.isAdded(uuid)) {
+                if (!Permissions.hasPermission(pp, "plots.admin.interact.other")) {
+                    MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, "plots.admin.interact.other");
+                    cancelled = true;
                 }
             }
         }
         if (cancelled) {
-            if (current.getTypeId() == newItem.getTypeId() && current.getDurability() == newItem.getDurability()) {
-                event.setCursor(new ItemStack(newItem.getTypeId(), newItem.getAmount(), newItem.getDurability()));
+            if ((current.getType() == newItem.getType()) && (current.getDurability() == newItem.getDurability())) {
+                event.setCursor(new ItemStack(newItem.getType(), newItem.getAmount(), newItem.getDurability()));
                 event.setCancelled(true);
                 return;
             }
-            event.setCursor(new ItemStack(newItem.getTypeId(), newItem.getAmount(), newItem.getDurability()));
+            event.setCursor(new ItemStack(newItem.getType(), newItem.getAmount(), newItem.getDurability()));
         }
     }
     
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onInteract(final PlayerInteractAtEntityEvent e) {
+    public void onInteract(PlayerInteractAtEntityEvent e) {
         Entity entity = e.getRightClicked();
         if (!(entity instanceof ArmorStand)) {
             return;
         }
-        final Location l = BukkitUtil.getLocation(e.getRightClicked().getLocation());
-        String world = l.getWorld();
-        if (!PS.get().isPlotWorld(world)) {
+        Location l = BukkitUtil.getLocation(e.getRightClicked().getLocation());
+        PlotArea area = l.getPlotArea();
+        if (area == null) {
             return;
         }
-        Plot plot = MainUtil.getPlot(l);
+        Plot plot = area.getPlotAbs(l);
         PlotPlayer pp = BukkitUtil.getPlayer(e.getPlayer());
         if (plot == null) {
-            if (!MainUtil.isPlotArea(l)) {
-                return;
-            }
             if (!Permissions.hasPermission(pp, "plots.admin.interact.road")) {
                 MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, "plots.admin.interact.road");
                 e.setCancelled(true);
             }
-        }
-        else {
-            if (!plot.hasOwner()) {
-                if (!Permissions.hasPermission(pp, "plots.admin.interact.unowned")) {
-                    MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, "plots.admin.interact.unowned");
-                    e.setCancelled(true);
-                }
+        } else if (!plot.hasOwner()) {
+            if (!Permissions.hasPermission(pp, "plots.admin.interact.unowned")) {
+                MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, "plots.admin.interact.unowned");
+                e.setCancelled(true);
             }
-            else {
-                final UUID uuid = pp.getUUID();
-                if (!plot.isAdded(uuid)) {
-                    if (!Permissions.hasPermission(pp, "plots.admin.interact.other")) {
-                        MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, "plots.admin.interact.other");
-                        e.setCancelled(true);
-                    }
+        } else {
+            UUID uuid = pp.getUUID();
+            if (!plot.isAdded(uuid)) {
+                if (!Permissions.hasPermission(pp, "plots.admin.interact.other")) {
+                    MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, "plots.admin.interact.other");
+                    e.setCancelled(true);
                 }
             }
         }

Bukkit/src/main/java/com/plotsquared/bukkit/listeners/PlayerEvents_1_9.java

@@ -0,0 +1,34 @@
+package com.plotsquared.bukkit.listeners;
+
+import com.intellectualcrafters.plot.PS;
+import com.intellectualcrafters.plot.object.Location;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import org.bukkit.entity.LingeringPotion;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.LingeringPotionSplashEvent;
+
+/**
+ * Created by Jesse on 3/30/2016.
+ */
+public class PlayerEvents_1_9 implements Listener {
+
+    private final PlayerEvents parent;
+
+    public PlayerEvents_1_9(PlayerEvents parent) {
+        this.parent = parent;
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPotionSplash(LingeringPotionSplashEvent event) {
+        LingeringPotion entity = event.getEntity();
+        Location l = BukkitUtil.getLocation(entity);
+        if (!PS.get().hasPlotArea(l.getWorld())) {
+            return;
+        }
+        if (!parent.onProjectileHit(event)) {
+            event.setCancelled(true);
+        }
+    }
+}

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

@@ -0,0 +1,190 @@
+package com.plotsquared.bukkit.listeners;
+
+import com.intellectualcrafters.plot.flag.Flag;
+import com.intellectualcrafters.plot.flag.FlagManager;
+import com.intellectualcrafters.plot.object.Plot;
+import com.intellectualcrafters.plot.object.PlotPlayer;
+import com.plotsquared.bukkit.events.PlayerEnterPlotEvent;
+import com.plotsquared.bukkit.events.PlayerLeavePlotEvent;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.listener.PlotListener;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.entity.EntityType;
+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.BlockDamageEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerPickupItemEvent;
+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.UUID;
+
+public class PlotPlusListener extends PlotListener implements Listener {
+
+    private static final HashMap<String, Interval> feedRunnable = new HashMap<>();
+    private static final HashMap<String, Interval> healRunnable = new HashMap<>();
+
+    public static void startRunnable(JavaPlugin plugin) {
+        plugin.getServer().getScheduler().scheduleSyncRepeatingTask(plugin, new Runnable() {
+            @Override
+            public void run() {
+                if (!healRunnable.isEmpty()) {
+                    for (Iterator<Entry<String, Interval>> iterator = healRunnable.entrySet().iterator(); iterator.hasNext(); ) {
+                        Entry<String, 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<String, Interval>> iterator = feedRunnable.entrySet().iterator(); iterator.hasNext(); ) {
+                        Entry<String, 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 (FlagManager.isBooleanFlag(plot, "instabreak", false)) {
+            event.getBlock().breakNaturally();
+        }
+    }
+    
+    @EventHandler(priority = EventPriority.HIGH)
+    public void onDamage(EntityDamageEvent event) {
+        if (event.getEntityType() != EntityType.PLAYER) {
+            return;
+        }
+        Player player = (Player) event.getEntity();
+        Plot plot = BukkitUtil.getLocation(player).getOwnedPlot();
+        if (plot == null) {
+            return;
+        }
+        if (FlagManager.isBooleanFlag(plot, "invincible", false)) {
+            event.setCancelled(true);
+        }
+    }
+    
+    @EventHandler
+    public void onItemPickup(PlayerPickupItemEvent 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) && FlagManager.isBooleanFlag(plot, "drop-protection", false)) {
+            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) && FlagManager.isBooleanFlag(plot, "item-drop", false)) {
+            event.setCancelled(true);
+        }
+    }
+    
+    @EventHandler
+    public void onPlotEnter(PlayerEnterPlotEvent event) {
+        Player player = event.getPlayer();
+        Plot plot = event.getPlot();
+        Flag feed = FlagManager.getPlotFlagRaw(plot, "feed");
+        if (feed != null) {
+            Integer[] value = (Integer[]) feed.getValue();
+            feedRunnable.put(player.getName(), new Interval(value[0], value[1], 20));
+        }
+        Flag heal = FlagManager.getPlotFlagRaw(plot, "heal");
+        if (heal != null) {
+            Integer[] value = (Integer[]) heal.getValue();
+            healRunnable.put(player.getName(), new Interval(value[0], value[1], 20));
+        }
+    }
+    
+    @EventHandler
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        Player player = event.getPlayer();
+        String name = player.getName();
+        feedRunnable.remove(name);
+        healRunnable.remove(name);
+    }
+    
+    @EventHandler
+    public void onPlotLeave(PlayerLeavePlotEvent event) {
+        Player leaver = event.getPlayer();
+        Plot plot = event.getPlot();
+        if (!plot.hasOwner()) {
+            return;
+        }
+        BukkitUtil.getPlayer(leaver);
+        String name = leaver.getName();
+        feedRunnable.remove(name);
+        healRunnable.remove(name);
+    }
+
+    private static class Interval {
+
+        final int interval;
+        final int amount;
+        final int max;
+        public int count = 0;
+
+        Interval(int interval, int amount, int max) {
+            this.interval = interval;
+            this.amount = amount;
+            this.max = max;
+        }
+    }
+
+}

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

@@ -0,0 +1,26 @@
+package com.plotsquared.bukkit.listeners;
+
+import com.intellectualcrafters.plot.PS;
+import com.intellectualcrafters.plot.generator.GeneratorWrapper;
+import com.plotsquared.bukkit.generator.BukkitPlotGenerator;
+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;
+
+public class WorldEvents implements Listener {
+    
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onWorldInit(WorldInitEvent event) {
+        World world = event.getWorld();
+        String name = world.getName();
+        ChunkGenerator gen = world.getGenerator();
+        if (gen instanceof GeneratorWrapper) {
+            PS.get().loadWorld(name, (GeneratorWrapper<?>) gen);
+        } else {
+            PS.get().loadWorld(name, new BukkitPlotGenerator(name, gen));
+        }
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/listeners/worldedit/WEListener.java

@@ -1,16 +1,5 @@
 package com.plotsquared.bukkit.listeners.worldedit;
 
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.List;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerCommandPreprocessEvent;
-
 import com.intellectualcrafters.plot.PS;
 import com.intellectualcrafters.plot.config.C;
 import com.intellectualcrafters.plot.config.Settings;
@@ -19,36 +8,45 @@ import com.intellectualcrafters.plot.object.PlotPlayer;
 import com.intellectualcrafters.plot.object.RegionWrapper;
 import com.intellectualcrafters.plot.util.MainUtil;
 import com.intellectualcrafters.plot.util.Permissions;
+import com.intellectualcrafters.plot.util.SetQueue;
 import com.plotsquared.bukkit.BukkitMain;
 import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.listener.WEManager;
 import com.sk89q.worldedit.BlockVector;
+import com.sk89q.worldedit.bukkit.WorldEditPlugin;
 import com.sk89q.worldedit.bukkit.selections.Selection;
- 
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+
 public class WEListener implements Listener {
-    
-    public final HashSet<String> rad1 = new HashSet<>(Arrays.asList("forestgen", "pumpkins", "drain", "fixwater", "fixlava", "replacenear", "snow", "thaw", "ex", "butcher", "size"));
+
+    public final HashSet<String> rad1 = new HashSet<>(
+            Arrays.asList("forestgen", "pumpkins", "drain", "fixwater", "fixlava", "replacenear", "snow", "thaw", "ex", "butcher", "size"));
     public final HashSet<String> rad2 = new HashSet<>(Arrays.asList("fill", "fillr", "removenear", "remove"));
     public final HashSet<String> rad2_1 = new HashSet<>(Arrays.asList("hcyl", "cyl"));
     public final HashSet<String> rad2_2 = new HashSet<>(Arrays.asList("sphere", "pyramid"));
-    public final HashSet<String> rad2_3 = new HashSet<>(Arrays.asList("brush smooth"));
-    public final HashSet<String> rad3_1 = new HashSet<>(Arrays.asList("brush gravity"));
+    public final HashSet<String> rad2_3 = new HashSet<>(Collections.singletonList("brush smooth"));
+    public final HashSet<String> rad3_1 = new HashSet<>(Collections.singletonList("brush gravity"));
     public final HashSet<String> rad3_2 = new HashSet<>(Arrays.asList("brush sphere", "brush cylinder"));
-    
-    public final HashSet<String> region  = new HashSet<>(Arrays.asList("move", "set", "replace", "overlay", "walls", "outline", "deform", "hollow", "smooth", "naturalize", "paste", "count", "distr", "regen", "copy", "cut", "green", "setbiome"));
-    public final HashSet<String> regionExtend = new HashSet<>(Arrays.asList("stack"));
-    public final HashSet<String> unregioned = new HashSet<>(Arrays.asList("paste", "redo", "undo", "rotate", "flip", "generate", "schematic", "schem"));
-    public final HashSet<String> unsafe1 =  new HashSet<>(Arrays.asList("cs", ".s", "restore", "snapshot", "delchunks", "listchunks"));
-    public final HashSet<String> restricted = new HashSet<>(Arrays.asList("up"));
-    
-    public boolean checkCommand(List<String> list, String cmd) {
-        for (String identifier : list) {
-            if (("/" + identifier).equals(cmd) || ("//" + identifier).equals(cmd) || ("/worldedit:/" + identifier).equals(cmd) || ("/worldedit:" + identifier).equals(cmd)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    
+
+    public final HashSet<String> region = new HashSet<>(
+            Arrays.asList("move", "set", "replace", "overlay", "walls", "outline", "deform", "hollow", "smooth", "naturalize", "paste", "count",
+                    "distr",
+                    "regen", "copy", "cut", "green", "setbiome"));
+    public final HashSet<String> regionExtend = new HashSet<>(Collections.singletonList("stack"));
+    public final HashSet<String> restricted = new HashSet<>(Collections.singletonList("up"));
+    public final HashSet<String> other = new HashSet<>(Arrays.asList("undo", "redo"));
+
     public String reduceCmd(String cmd, boolean single) {
         if (cmd.startsWith("/worldedit:/")) {
             return cmd.substring(12);
@@ -64,7 +62,7 @@ public class WEListener implements Listener {
         }
         return cmd;
     }
-    
+
     public int getInt(String s) {
         try {
             int max = 0;
@@ -76,12 +74,11 @@ public class WEListener implements Listener {
                 }
             }
             return max;
-        }
-        catch (NumberFormatException e) {
+        } catch (NumberFormatException e) {
             return 0;
         }
     }
-    
+
     public boolean checkVolume(PlotPlayer player, long volume, long max, Cancellable e) {
         if (volume > max) {
             MainUtil.sendMessage(player, C.WORLDEDIT_VOLUME.s().replaceAll("%current%", volume + "").replaceAll("%max%", max + ""));
@@ -92,25 +89,23 @@ public class WEListener implements Listener {
         }
         return true;
     }
-    
+
     public boolean checkSelection(Player p, PlotPlayer pp, int modifier, long max, Cancellable e) {
-        final Selection selection = BukkitMain.worldEdit.getSelection(p);
+        Selection selection = BukkitMain.worldEdit.getSelection(p);
         if (selection == null) {
             return true;
         }
-        final BlockVector pos1 = selection.getNativeMinimumPoint().toBlockVector();
-        final BlockVector pos2 = selection.getNativeMaximumPoint().toBlockVector();
+        BlockVector pos1 = selection.getNativeMinimumPoint().toBlockVector();
+        BlockVector pos2 = selection.getNativeMaximumPoint().toBlockVector();
         HashSet<RegionWrapper> mask = WEManager.getMask(pp);
         RegionWrapper region = new RegionWrapper(pos1.getBlockX(), pos2.getBlockX(), pos1.getBlockZ(), pos2.getBlockZ());
         if (Settings.REQUIRE_SELECTION) {
             String arg = null;
             if (!WEManager.regionContains(region, mask)) {
                 arg = "pos1 + pos2";
-            }
-            else if (!WEManager.maskContains(mask, pos1.getBlockX(), pos1.getBlockZ())) {
+            } else if (!WEManager.maskContains(mask, pos1.getBlockX(), pos1.getBlockY(), pos1.getBlockZ())) {
                 arg = "pos1";
-            }
-            else if (!WEManager.maskContains(mask, pos2.getBlockX(), pos2.getBlockZ())) {
+            } else if (!WEManager.maskContains(mask, pos2.getBlockX(), pos2.getBlockY(), pos2.getBlockZ())) {
                 arg = "pos2";
             }
             if (arg != null) {
@@ -130,48 +125,97 @@ public class WEListener implements Listener {
                 return true;
             }
         }
-        long volume = Math.abs((pos1.getBlockX() - pos2.getBlockX()) * (pos1.getBlockY() - pos2.getBlockY()) * (pos1.getBlockZ() - pos2.getBlockZ())) * modifier;
+        long volume = Math.abs((pos1.getBlockX() - pos2.getBlockX()) * (pos1.getBlockY() - pos2.getBlockY()) * (pos1.getBlockZ() - pos2.getBlockZ()))
+                * modifier;
         return checkVolume(pp, volume, max, e);
     }
-    
+
+    public boolean delay(final Player player, final String command, boolean delayed) {
+        if (!Settings.QUEUE_COMMANDS || !Settings.EXPERIMENTAL_FAST_ASYNC_WORLDEDIT) {
+            return false;
+        }
+        boolean free = SetQueue.IMP.addTask(null);
+        if (free) {
+            if (delayed) {
+                MainUtil.sendMessage(BukkitUtil.getPlayer(player), C.WORLDEDIT_RUN, command);
+                Bukkit.getServer().dispatchCommand(player, command.substring(1));
+            } else {
+                return false;
+            }
+        } else {
+            if (!delayed) {
+                MainUtil.sendMessage(BukkitUtil.getPlayer(player), C.WORLDEDIT_DELAYED);
+            }
+            SetQueue.IMP.addTask(new Runnable() {
+                @Override
+                public void run() {
+                    delay(player, command, true);
+                }
+            });
+        }
+        return true;
+    }
+
     @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
-    public boolean onPlayerCommand(final PlayerCommandPreprocessEvent e) {
-        final Player p = e.getPlayer();
-        final PlotPlayer pp = BukkitUtil.getPlayer(p);
-        if (!PS.get().isPlotWorld(p.getWorld().getName())) {
+    public boolean onPlayerCommand(PlayerCommandPreprocessEvent e) {
+        WorldEditPlugin worldedit = BukkitMain.worldEdit;
+        if (worldedit == null) {
+            HandlerList.unregisterAll(this);
             return true;
         }
-        String cmd = e.getMessage().toLowerCase();
-        boolean single = true;
+        Player p = e.getPlayer();
+        PlotPlayer pp = BukkitUtil.getPlayer(p);
+        if (!PS.get().hasPlotArea(p.getWorld().getName())) {
+            return true;
+        }
+        String message = e.getMessage();
+        String cmd = message.toLowerCase();
         String[] split = cmd.split(" ");
-        
+
         long maxVolume = Settings.WE_MAX_VOLUME;
         long maxIterations = Settings.WE_MAX_ITERATIONS;
-        if (pp.getAttribute("worldedit" )) {
+        if (pp.getAttribute("worldedit")) {
             return true;
         }
+        boolean single = true;
         if (split.length >= 2) {
             String reduced = reduceCmd(split[0], single);
             String reduced2 = reduceCmd(split[0] + " " + split[1], single);
-            if (rad1.contains(reduced)) {
+            if (this.rad1.contains(reduced)) {
+                if (delay(p, message, false)) {
+                    e.setCancelled(true);
+                    return true;
+                }
                 long volume = getInt(split[1]) * 256;
                 return checkVolume(pp, volume, maxVolume, e);
             }
-            if (rad2.contains(reduced)) {
+            if (this.rad2.contains(reduced)) {
+                if (delay(p, message, false)) {
+                    e.setCancelled(true);
+                    return true;
+                }
                 if (split.length >= 3) {
                     long volume = getInt(split[2]) * 256;
                     return checkVolume(pp, volume, maxVolume, e);
                 }
                 return true;
             }
-            if (rad2_1.contains(reduced)) {
+            if (this.rad2_1.contains(reduced)) {
+                if (delay(p, message, false)) {
+                    e.setCancelled(true);
+                    return true;
+                }
                 if (split.length >= 4) {
                     long volume = getInt(split[2]) * getInt(split[3]);
                     return checkVolume(pp, volume, maxVolume, e);
                 }
                 return true;
             }
-            if (rad2_2.contains(reduced)) {
+            if (this.rad2_2.contains(reduced)) {
+                if (delay(p, message, false)) {
+                    e.setCancelled(true);
+                    return true;
+                }
                 if (split.length >= 3) {
                     long radius = getInt(split[2]);
                     long volume = radius * radius;
@@ -179,12 +223,17 @@ public class WEListener implements Listener {
                 }
                 return true;
             }
-            if (rad2_3.contains(reduced2)) {
+            if (this.rad2_3.contains(reduced2)) {
+                if (delay(p, message, false)) {
+                    e.setCancelled(true);
+                    return true;
+                }
                 if (split.length >= 3) {
                     if (split.length == 4) {
                         int iterations = getInt(split[3]);
                         if (iterations > maxIterations) {
-                            MainUtil.sendMessage(pp, C.WORLDEDIT_ITERATIONS.s().replaceAll("%current%", iterations + "").replaceAll("%max%", maxIterations + ""));
+                            MainUtil.sendMessage(pp,
+                                    C.WORLDEDIT_ITERATIONS.s().replaceAll("%current%", iterations + "").replaceAll("%max%", maxIterations + ""));
                             e.setCancelled(true);
                             if (Permissions.hasPermission(pp, "plots.worldedit.bypass")) {
                                 MainUtil.sendMessage(pp, C.WORLDEDIT_BYPASS);
@@ -198,7 +247,11 @@ public class WEListener implements Listener {
                 }
                 return true;
             }
-            if (rad3_1.contains(reduced2)) {
+            if (this.rad3_1.contains(reduced2)) {
+                if (delay(p, message, false)) {
+                    e.setCancelled(true);
+                    return true;
+                }
                 if (split.length >= 3) {
                     int i = 2;
                     if (split[i].equalsIgnoreCase("-h")) {
@@ -210,7 +263,11 @@ public class WEListener implements Listener {
                 }
                 return true;
             }
-            if (rad3_2.contains(reduced2)) {
+            if (this.rad3_2.contains(reduced2)) {
+                if (delay(p, message, false)) {
+                    e.setCancelled(true);
+                    return true;
+                }
                 if (split.length >= 4) {
                     int i = 3;
                     if (split[i].equalsIgnoreCase("-h")) {
@@ -222,7 +279,11 @@ public class WEListener implements Listener {
                 }
                 return true;
             }
-            if (regionExtend.contains(reduced)) {
+            if (this.regionExtend.contains(reduced)) {
+                if (delay(p, message, false)) {
+                    e.setCancelled(true);
+                    return true;
+                }
                 return checkSelection(p, pp, getInt(split[1]), maxVolume, e);
             }
         }
@@ -234,9 +295,13 @@ public class WEListener implements Listener {
                 MainUtil.sendMessage(pp, C.WORLDEDIT_BYPASS);
             }
         }
-        if (restricted.contains(reduced)) {
-            Plot plot = MainUtil.getPlot(pp.getLocation());
-            if (plot != null && plot.isAdded(pp.getUUID())) {
+        if (this.restricted.contains(reduced)) {
+            Plot plot = pp.getCurrentPlot();
+            if ((plot != null) && plot.isAdded(pp.getUUID())) {
+                if (delay(p, message, false)) {
+                    e.setCancelled(true);
+                    return true;
+                }
                 return true;
             }
             e.setCancelled(true);
@@ -246,10 +311,19 @@ public class WEListener implements Listener {
             }
             return true;
         }
-        if (region.contains(reduced)) {
+        if (this.region.contains(reduced)) {
+            if (delay(p, message, false)) {
+                e.setCancelled(true);
+                return true;
+            }
             return checkSelection(p, pp, 1, maxVolume, e);
         }
+        if (this.other.contains(reduced)) {
+            if (delay(p, message, false)) {
+                e.setCancelled(true);
+                return true;
+            }
+        }
         return true;
     }
 }
- 

Bukkit/src/main/java/com/plotsquared/bukkit/object/BukkitLazyBlock.java

@@ -1,41 +1,39 @@
 package com.plotsquared.bukkit.object;
 
-import org.bukkit.block.Block;
-
 import com.intellectualcrafters.plot.object.LazyBlock;
 import com.intellectualcrafters.plot.object.PlotBlock;
+import org.bukkit.block.Block;
 
 public class BukkitLazyBlock extends LazyBlock {
 
-    private int id = -1;
+    private int id;
     private Block block;
     private PlotBlock pb;
-    
-    
+
     public BukkitLazyBlock(int id, Block block) {
         this.id = id;
         this.block = block;
     }
-    
+
     public BukkitLazyBlock(PlotBlock pb) {
         this.id = pb.id;
         this.pb = pb;
     }
-    
+
     public BukkitLazyBlock(Block block) {
         this.block = block;
     }
-    
+
     @Override
     public PlotBlock getPlotBlock() {
-        if (pb != null) {
-            return pb;
+        if (this.pb != null) {
+            return this.pb;
         }
-        if (id == -1 ) {
-            id = block.getTypeId();
+        if (this.id == 0) {
+            this.id = this.block.getTypeId();
         }
         byte data;
-        switch(id) {
+        switch (this.id) {
             case 0:
             case 2:
             case 4:
@@ -59,7 +57,6 @@ public class BukkitLazyBlock extends LazyBlock {
             case 47:
             case 48:
             case 49:
-            case 50:
             case 51:
             case 52:
             case 54:
@@ -77,8 +74,6 @@ public class BukkitLazyBlock extends LazyBlock {
             case 11:
             case 73:
             case 74:
-            case 75:
-            case 76:
             case 78:
             case 79:
             case 80:
@@ -122,20 +117,22 @@ public class BukkitLazyBlock extends LazyBlock {
             case 191:
             case 192:
                 data = 0;
+                break;
             default:
-                data = block.getData();
+                data = this.block.getData();
+                break;
         }
-        pb = new PlotBlock((short) id, data);
-        return pb;
-        
+        this.pb = new PlotBlock((short) this.id, data);
+        return this.pb;
+
     }
-    
+
     @Override
     public int getId() {
-        if (id == -1) {
-            id = block.getTypeId();
+        if (this.id == 0) {
+            this.id = this.block.getTypeId();
         }
-        return id;
+        return this.id;
     }
-    
+
 }

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

@@ -1,38 +1,39 @@
 package com.plotsquared.bukkit.object;
 
+import com.intellectualcrafters.plot.object.OfflinePlotPlayer;
+import org.bukkit.OfflinePlayer;
+
 import java.util.UUID;
 
-import org.bukkit.OfflinePlayer;
-
-import com.intellectualcrafters.plot.object.OfflinePlotPlayer;
-
 public class BukkitOfflinePlayer implements OfflinePlotPlayer {
-    
+
     public final OfflinePlayer player;
 
     /**
-     * Please do not use this method. Instead use BukkitUtil.getPlayer(Player), as it caches player objects.
+     * <p>Please do not use this method. Instead use BukkitUtil.getPlayer(Player),
+     * as it caches player objects.</p>
+     *
      * @param player
      */
-    public BukkitOfflinePlayer(final OfflinePlayer player) {
+    public BukkitOfflinePlayer(OfflinePlayer player) {
         this.player = player;
     }
-    
+
     @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/plotsquared/bukkit/object/BukkitPlayer.java

@@ -0,0 +1,201 @@
+package com.plotsquared.bukkit.object;
+
+import com.intellectualcrafters.plot.object.Location;
+import com.intellectualcrafters.plot.object.PlotPlayer;
+import com.intellectualcrafters.plot.util.EconHandler;
+import com.intellectualcrafters.plot.util.PlotGameMode;
+import com.intellectualcrafters.plot.util.PlotWeather;
+import com.intellectualcrafters.plot.util.UUIDHandler;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import org.bukkit.Effect;
+import org.bukkit.GameMode;
+import org.bukkit.WeatherType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
+
+import java.util.UUID;
+
+public class BukkitPlayer extends PlotPlayer {
+    
+    public final Player player;
+    public boolean offline;
+    private UUID uuid;
+    private String name;
+    private long last = 0;
+    
+    /**
+     * <p>Please do not use this method. Instead use
+     * BukkitUtil.getPlayer(Player), as it caches player objects.</p>
+     * @param player
+     */
+    public BukkitPlayer(Player player) {
+        this.player = player;
+        super.populatePersistentMetaMap();
+    }
+
+    public BukkitPlayer(Player player, boolean offline) {
+        this.player = player;
+        this.offline = offline;
+        super.populatePersistentMetaMap();
+    }
+    
+    @Override
+    public long getPreviousLogin() {
+        if (this.last == 0) {
+            this.last = this.player.getLastPlayed();
+        }
+        return this.last;
+    }
+    
+    @Override
+    public Location getLocation() {
+        Location location = super.getLocation();
+        return location == null ? BukkitUtil.getLocation(this.player) : location;
+    }
+    
+    @Override
+    public UUID getUUID() {
+        if (this.uuid == null) {
+            this.uuid = UUIDHandler.getUUID(this);
+        }
+        return this.uuid;
+    }
+    
+    @Override
+    public boolean hasPermission(String permission) {
+        if (this.offline && EconHandler.manager != null) {
+            return EconHandler.manager.hasPermission(getName(), permission);
+        }
+        return this.player.hasPermission(permission);
+    }
+
+    @Override
+    public void sendMessage(String message) {
+        this.player.sendMessage(message);
+    }
+    
+    @Override
+    public void teleport(Location location) {
+        if (Math.abs(location.getX()) >= 30000000 || Math.abs(location.getZ()) >= 30000000) {
+            return;
+        }
+        this.player.teleport(
+                new org.bukkit.Location(BukkitUtil.getWorld(location.getWorld()), location.getX() + 0.5, location.getY(), location.getZ() + 0.5,
+                        location.getYaw(), location.getPitch()), TeleportCause.COMMAND);
+    }
+    
+    @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(PlotWeather weather) {
+        switch (weather) {
+            case CLEAR:
+                this.player.setPlayerWeather(WeatherType.CLEAR);
+                break;
+            case RAIN:
+                this.player.setPlayerWeather(WeatherType.DOWNFALL);
+                break;
+            case RESET:
+                this.player.resetPlayerWeather();
+                break;
+            default:
+                this.player.resetPlayerWeather();
+                break;
+        }
+    }
+    
+    @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(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:
+                this.player.setGameMode(GameMode.SURVIVAL);
+                break;
+            default:
+                this.player.setGameMode(GameMode.SURVIVAL);
+                break;
+        }
+    }
+    
+    @Override
+    public void setTime(long time) {
+        if (time != Long.MAX_VALUE) {
+            this.player.setPlayerTime(time, false);
+        } else {
+            this.player.resetPlayerTime();
+        }
+    }
+    
+    @Override
+    public void setFlight(boolean fly) {
+        this.player.setAllowFlight(fly);
+    }
+    
+    @Override
+    public void playMusic(Location location, int id) {
+        this.player.playEffect(BukkitUtil.getLocation(location), Effect.RECORD_PLAY, id);
+    }
+    
+    @Override
+    public void kick(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/plotsquared/bukkit/object/entity/AgeableStats.java

@@ -1,4 +1,4 @@
-package com.intellectualcrafters.plot.object.entity;
+package com.plotsquared.bukkit.object.entity;
 
 public class AgeableStats {
     public int age;

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

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

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

@@ -1,6 +1,5 @@
-package com.intellectualcrafters.plot.object.entity;
+package com.plotsquared.bukkit.object.entity;
 
-import com.plotsquared.bukkit.object.entity.EntityWrapper;
 
 public class EntityBaseStats {
     public EntityWrapper passenger;

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

@@ -1,5 +1,6 @@
 package com.plotsquared.bukkit.object.entity;
 
+import com.intellectualcrafters.plot.PS;
 import org.bukkit.Art;
 import org.bukkit.DyeColor;
 import org.bukkit.Location;
@@ -31,14 +32,10 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.util.EulerAngle;
 import org.bukkit.util.Vector;
 
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.object.entity.AgeableStats;
-import com.intellectualcrafters.plot.object.entity.ArmorStandStats;
-import com.intellectualcrafters.plot.object.entity.EntityBaseStats;
-import com.intellectualcrafters.plot.object.entity.HorseStats;
-
 public class EntityWrapper {
-    public short id;
+
+    private final int hash;
+    public EntityType type;
     public float yaw;
     public float pitch;
     public double x;
@@ -57,140 +54,30 @@ public class EntityWrapper {
     public TameableStats tamed;
     private HorseStats horse;
     private ArmorStandStats stand;
-
-    private int hash;
     
-    @Override
-    public boolean equals(Object obj) {
-        return hash == obj.hashCode();
-    }
-    
-    @Override
-    public int hashCode() {
-        return hash;
-    }
-    
-    public void storeInventory(final InventoryHolder held) {
-        this.inventory = held.getInventory().getContents().clone();
-    }
-
-    private void restoreLiving(final LivingEntity entity) {
-        if (this.lived.loot) {
-            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.size() > 0)) {
-            entity.addPotionEffects(this.lived.potions);
-        }
-        entity.setRemainingAir(this.lived.air);
-        entity.setRemoveWhenFarAway(this.lived.persistent);
-        if (this.lived.equipped) {
-            final EntityEquipment equipment = entity.getEquipment();
-            equipment.setItemInHand(this.lived.hands);
-            equipment.setHelmet(this.lived.helmet);
-            equipment.setChestplate(this.lived.chestplate);
-            equipment.setLeggings(this.lived.leggings);
-            equipment.setBoots(this.lived.boots);
-        }
-        if (this.lived.leashed) {
-            // TODO leashes
-            //            World world = entity.getWorld();
-            //            Entity leash = world.spawnEntity(new Location(world, Math.floor(x) + lived.leash_x, Math.floor(y) + lived.leash_y, Math.floor(z) + lived.leash_z), EntityType.LEASH_HITCH);
-            //            entity.setLeashHolder(leash);
-        }
-    }
-
-    private void restoreInventory(final InventoryHolder entity) {
-        entity.getInventory().setContents(this.inventory);
-    }
-
-    public void storeLiving(final 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) {
-            final Location loc = lived.getLeashHolder().getLocation();
-            this.lived.leash_x = (short) (this.x - loc.getBlockX());
-            this.lived.leash_y = (short) (this.y - loc.getBlockY());
-            this.lived.leash_z = (short) (this.z - loc.getBlockZ());
-        }
-        final EntityEquipment equipment = lived.getEquipment();
-        this.lived.equipped = equipment != null;
-        if (this.lived.equipped) {
-            this.lived.hands = equipment.getItemInHand().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(final Tameable entity) {
-        if (this.tamed.tamed) {
-            if (this.tamed.owner != null) {
-                entity.setTamed(true);
-                entity.setOwner(this.tamed.owner);
-            }
-        }
-    }
-
-    private void restoreAgeable(final Ageable entity) {
-        if (!this.aged.adult) {
-            entity.setBaby();
-        }
-        if (this.aged.locked) {
-            entity.setAgeLock(this.aged.locked);
-        }
-        if (this.aged.age > 0) {
-            entity.setAge(this.aged.age);
-        }
-    }
-
-    public void storeAgeable(final Ageable aged) {
-        this.aged = new AgeableStats();
-        this.aged.age = aged.getAge();
-        this.aged.locked = aged.getAgeLock();
-        this.aged.adult = aged.isAdult();
-    }
-
-    public void storeTameable(final Tameable tamed) {
-        this.tamed = new TameableStats();
-        this.tamed.owner = tamed.getOwner();
-        this.tamed.tamed = tamed.isTamed();
-    }
-
     @SuppressWarnings("deprecation")
-    public EntityWrapper(final org.bukkit.entity.Entity entity, final short depth) {
+    public EntityWrapper(Entity entity, short depth) {
         this.hash = entity.getEntityId();
         this.depth = depth;
-        final Location loc = entity.getLocation();
+        Location loc = entity.getLocation();
         this.yaw = loc.getYaw();
         this.pitch = loc.getPitch();
         this.x = loc.getX();
         this.y = loc.getY();
         this.z = loc.getZ();
-        this.id = entity.getType().getTypeId();
+        this.type = entity.getType();
         if (depth == 0) {
             return;
         }
         this.base = new EntityBaseStats();
-        final Entity p = entity.getPassenger();
+        Entity p = entity.getPassenger();
         if (p != null) {
             this.base.passenger = new EntityWrapper(p, depth);
         }
         this.base.fall = entity.getFallDistance();
         this.base.fire = (short) entity.getFireTicks();
         this.base.age = entity.getTicksLived();
-        final Vector velocity = entity.getVelocity();
+        Vector velocity = entity.getVelocity();
         this.base.v_x = velocity.getX();
         this.base.v_y = velocity.getY();
         this.base.v_z = velocity.getZ();
@@ -226,58 +113,55 @@ public class EntityWrapper {
             case THROWN_EXP_BOTTLE:
             case WEATHER:
             case WITHER_SKULL:
-            case UNKNOWN: {
+            case UNKNOWN:
+            case TIPPED_ARROW:
+            case SPECTRAL_ARROW:
+            case SHULKER_BULLET:
+            case DRAGON_FIREBALL:
+            case LINGERING_POTION:
+            case AREA_EFFECT_CLOUD:
                 // Do this stuff later
                 return;
-            }
-            default: {
+            default:
                 PS.debug("&cCOULD NOT IDENTIFY ENTITY: " + entity.getType());
                 return;
-            }
             // MISC //
-            case DROPPED_ITEM: {
-                final Item item = (Item) entity;
+            case DROPPED_ITEM:
+                Item item = (Item) entity;
                 this.stack = item.getItemStack();
                 return;
-            }
-            case ITEM_FRAME: {
-                final ItemFrame itemframe = (ItemFrame) entity;
+            case ITEM_FRAME:
+                ItemFrame itemframe = (ItemFrame) entity;
                 this.x = Math.floor(this.x);
                 this.y = Math.floor(this.y);
                 this.z = Math.floor(this.z);
                 this.dataByte = getOrdinal(Rotation.values(), itemframe.getRotation());
                 this.stack = itemframe.getItem().clone();
                 return;
-            }
-            case PAINTING: {
-                final Painting painting = (Painting) entity;
+            case PAINTING:
+                Painting painting = (Painting) entity;
                 this.x = Math.floor(this.x);
                 this.y = Math.floor(this.y);
                 this.z = Math.floor(this.z);
-                final Art a = painting.getArt();
+                Art a = painting.getArt();
                 this.dataByte = getOrdinal(BlockFace.values(), painting.getFacing());
-                final int h = a.getBlockHeight();
-                if ((h % 2) == 0) {
+                int h = a.getBlockHeight();
+                if (h % 2 == 0) {
                     this.y -= 1;
                 }
                 this.dataString = a.name();
                 return;
-            }
             // END MISC //
             // INVENTORY HOLDER //
-            case MINECART_CHEST: {
+            case MINECART_CHEST:
+            case MINECART_HOPPER:
                 storeInventory((InventoryHolder) entity);
                 return;
-            }
-            case MINECART_HOPPER: {
-                storeInventory((InventoryHolder) entity);
-                return;
-            }
             // START LIVING ENTITY //
             // START AGEABLE //
             // START TAMEABLE //
-            case HORSE: {
-                final Horse horse = (Horse) entity;
+            case HORSE:
+                Horse horse = (Horse) entity;
                 this.horse = new HorseStats();
                 this.horse.jump = horse.getJumpStrength();
                 this.horse.chest = horse.isCarryingChest();
@@ -289,77 +173,71 @@ public class EntityWrapper {
                 storeLiving((LivingEntity) entity);
                 storeInventory((InventoryHolder) entity);
                 return;
-            }
             // END INVENTORY HOLDER //
             case WOLF:
-            case OCELOT: {
+            case OCELOT:
                 storeTameable((Tameable) entity);
                 storeAgeable((Ageable) entity);
                 storeLiving((LivingEntity) entity);
                 return;
-            }
-            // END AMEABLE //
-            case SHEEP: {
-                final Sheep sheep = (Sheep) entity;
-                this.dataByte = (byte) ((sheep).isSheared() ? 1 : 0);
+            // END TAMEABLE //
+            case SHEEP:
+                Sheep sheep = (Sheep) entity;
+                this.dataByte = (byte) (sheep.isSheared() ? 1 : 0);
                 this.dataByte2 = sheep.getColor().getDyeData();
                 storeAgeable((Ageable) entity);
                 storeLiving((LivingEntity) entity);
                 return;
-            }
             case VILLAGER:
             case CHICKEN:
             case COW:
             case MUSHROOM_COW:
-            case PIG: {
+            case PIG:
                 storeAgeable((Ageable) entity);
                 storeLiving((LivingEntity) entity);
                 return;
-            }
-            // END AGEABLE //
-            case RABBIT: { // NEW
+            case RABBIT:  // NEW
                 this.dataByte = getOrdinal(Type.values(), ((Rabbit) entity).getRabbitType());
                 storeAgeable((Ageable) entity);
                 storeLiving((LivingEntity) entity);
                 return;
-            }
-            case GUARDIAN: { // NEW
+            // END AGEABLE //
+            case GUARDIAN:  // NEW
                 this.dataByte = (byte) (((Guardian) entity).isElder() ? 1 : 0);
                 storeLiving((LivingEntity) entity);
                 return;
-            }
-            case SKELETON: { // NEW
+            case SKELETON:  // NEW
                 this.dataByte = (byte) ((Skeleton) entity).getSkeletonType().getId();
                 storeLiving((LivingEntity) entity);
                 return;
-            }
-            case ARMOR_STAND: { // NEW
+            case ARMOR_STAND:  // NEW
                 // CHECK positions
-                final ArmorStand stand = (ArmorStand) entity;
-                this.inventory = new ItemStack[] { stand.getItemInHand().clone(), stand.getHelmet().clone(), stand.getChestplate().clone(), stand.getLeggings().clone(), stand.getBoots().clone() };
+                ArmorStand stand = (ArmorStand) entity;
+                this.inventory = new ItemStack[]{stand.getItemInHand().clone(), stand.getHelmet().clone(), stand.getChestplate().clone(),
+                        stand.getLeggings().clone(), stand.getBoots().clone()};
                 storeLiving((LivingEntity) entity);
                 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();
@@ -369,7 +247,7 @@ public class EntityWrapper {
                 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;
                 }
@@ -386,7 +264,6 @@ public class EntityWrapper {
                     this.stand.small = true;
                 }
                 return;
-            }
             case ENDERMITE: // NEW
             case BAT:
             case ENDER_DRAGON:
@@ -404,43 +281,142 @@ public class EntityWrapper {
             case ENDERMAN:
             case CREEPER:
             case BLAZE:
+            case SHULKER:
             case SNOWMAN:
-            case IRON_GOLEM: {
+            case IRON_GOLEM:
                 storeLiving((LivingEntity) entity);
-                return;
-            }
-            // END LIVING //
+                // END LIVING //
         }
     }
 
+    @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();
+    }
+
+    private 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) {
+            EntityEquipment equipment = entity.getEquipment();
+            equipment.setItemInHand(this.lived.hands);
+            equipment.setHelmet(this.lived.helmet);
+            equipment.setChestplate(this.lived.chestplate);
+            equipment.setLeggings(this.lived.leggings);
+            equipment.setBoots(this.lived.boots);
+        }
+        if (this.lived.leashed) {
+            // TODO leashes
+            //            World world = entity.getWorld();
+            //            Entity leash = world.spawnEntity(new Location(world, Math.floor(x) + lived.leash_x, Math.floor(y) + lived.leash_y, Math
+            // .floor(z) + lived.leash_z), EntityType.LEASH_HITCH);
+            //            entity.setLeashHolder(leash);
+        }
+    }
+
+    private void restoreInventory(InventoryHolder entity) {
+        entity.getInventory().setContents(this.inventory);
+    }
+
+    public 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 loc = lived.getLeashHolder().getLocation();
+            this.lived.leash_x = (short) (this.x - loc.getBlockX());
+            this.lived.leash_y = (short) (this.y - loc.getBlockY());
+            this.lived.leash_z = (short) (this.z - loc.getBlockZ());
+        }
+        EntityEquipment equipment = lived.getEquipment();
+        this.lived.equipped = equipment != null;
+        if (this.lived.equipped) {
+            this.lived.hands = equipment.getItemInHand().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();
+    }
+
     @SuppressWarnings("deprecation")
-    public Entity spawn(final World world, final int x_offset, final int z_offset) {
-        final Location loc = new Location(world, this.x + x_offset, this.y, this.z + z_offset);
+    public Entity spawn(World world, int x_offset, int z_offset) {
+        Location loc = new Location(world, this.x + x_offset, this.y, this.z + z_offset);
         loc.setYaw(this.yaw);
         loc.setPitch(this.pitch);
-        if (this.id == -1) {
+        if (!this.type.isSpawnable()) {
             return null;
         }
-        final EntityType type = EntityType.fromId(this.id);
         Entity entity;
-        switch (type) {
-            case DROPPED_ITEM: {
+        switch (this.type) {
+            case DROPPED_ITEM:
                 return world.dropItem(loc, this.stack);
-            }
             case PLAYER:
-            case LEASH_HITCH: {
+            case LEASH_HITCH:
                 return null;
-            }
-            case ITEM_FRAME: {
+            case ITEM_FRAME:
                 entity = world.spawn(loc, ItemFrame.class);
                 break;
-            }
-            case PAINTING: {
+            case PAINTING:
                 entity = world.spawn(loc, Painting.class);
                 break;
-            }
             default:
-                entity = world.spawnEntity(loc, type);
+                entity = world.spawnEntity(loc, this.type);
                 break;
         }
         if (this.depth == 0) {
@@ -449,12 +425,18 @@ public class EntityWrapper {
         if (this.base.passenger != null) {
             try {
                 entity.setPassenger(this.base.passenger.spawn(world, x_offset, z_offset));
-            } catch (final Exception e) {
+            } catch (Exception e) {
             }
         }
-        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);
+        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.v_x, this.base.v_y, this.base.v_z));
         if (this.depth == 1) {
             return entity;
@@ -488,42 +470,34 @@ public class EntityWrapper {
             case WEATHER:
             case WITHER_SKULL:
             case MINECART_FURNACE:
-            case UNKNOWN: {
+            case UNKNOWN:
                 // Do this stuff later
                 return entity;
-            }
-            default: {
+            default:
                 PS.debug("&cCOULD NOT IDENTIFY ENTITY: " + entity.getType());
                 return entity;
-            }
             // MISC //
-            case ITEM_FRAME: {
-                final ItemFrame itemframe = (ItemFrame) entity;
+            case ITEM_FRAME:
+                ItemFrame itemframe = (ItemFrame) entity;
                 itemframe.setRotation(Rotation.values()[this.dataByte]);
                 itemframe.setItem(this.stack);
                 return entity;
-            }
-            case PAINTING: {
-                final Painting painting = (Painting) 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_CHEST:
+            case MINECART_HOPPER:
                 restoreInventory((InventoryHolder) entity);
                 return entity;
-            }
-            case MINECART_HOPPER: {
-                restoreInventory((InventoryHolder) entity);
-                return entity;
-            }
             // START LIVING ENTITY //
             // START AGEABLE //
             // START TAMEABLE //
-            case HORSE: {
-                final Horse horse = (Horse) entity;
+            case HORSE:
+                Horse horse = (Horse) entity;
                 horse.setJumpStrength(this.horse.jump);
                 horse.setCarryingChest(this.horse.chest);
                 horse.setVariant(Variant.values()[this.horse.variant]);
@@ -534,18 +508,16 @@ public class EntityWrapper {
                 restoreLiving((LivingEntity) entity);
                 restoreInventory((InventoryHolder) entity);
                 return entity;
-            }
             // END INVENTORY HOLDER //
             case WOLF:
-            case OCELOT: {
+            case OCELOT:
                 restoreTameable((Tameable) entity);
                 restoreAgeable((Ageable) entity);
                 restoreLiving((LivingEntity) entity);
                 return entity;
-            }
-            // END AMEABLE //
-            case SHEEP: {
-                final Sheep sheep = (Sheep) entity;
+            // END AGEABLE //
+            case SHEEP:
+                Sheep sheep = (Sheep) entity;
                 if (this.dataByte == 1) {
                     sheep.setSheared(true);
                 }
@@ -555,42 +527,37 @@ public class EntityWrapper {
                 restoreAgeable((Ageable) entity);
                 restoreLiving((LivingEntity) entity);
                 return entity;
-            }
             case VILLAGER:
             case CHICKEN:
             case COW:
             case MUSHROOM_COW:
-            case PIG: {
+            case PIG:
                 restoreAgeable((Ageable) entity);
                 restoreLiving((LivingEntity) entity);
                 return entity;
-            }
             // END AGEABLE //
-            case RABBIT: { // NEW
+            case RABBIT:  // NEW
                 if (this.dataByte != 0) {
                     ((Rabbit) entity).setRabbitType(Type.values()[this.dataByte]);
                 }
                 restoreAgeable((Ageable) entity);
                 restoreLiving((LivingEntity) entity);
                 return entity;
-            }
-            case GUARDIAN: { // NEW
+            case GUARDIAN:  // NEW
                 if (this.dataByte != 0) {
                     ((Guardian) entity).setElder(true);
                 }
                 restoreLiving((LivingEntity) entity);
                 return entity;
-            }
-            case SKELETON: { // NEW
+            case SKELETON:  // NEW
                 if (this.dataByte != 0) {
                     ((Skeleton) entity).setSkeletonType(SkeletonType.values()[this.dataByte]);
                 }
                 storeLiving((LivingEntity) entity);
                 return entity;
-            }
-            case ARMOR_STAND: { // NEW
+            case ARMOR_STAND:  // NEW
                 // CHECK positions
-                final ArmorStand stand = (ArmorStand) entity;
+                ArmorStand stand = (ArmorStand) entity;
                 if (this.inventory[0] != null) {
                     stand.setItemInHand(this.inventory[0]);
                 }
@@ -647,7 +614,6 @@ public class EntityWrapper {
                 }
                 restoreLiving((LivingEntity) entity);
                 return entity;
-            }
             case ENDERMITE: // NEW
             case BAT:
             case ENDER_DRAGON:
@@ -666,15 +632,14 @@ public class EntityWrapper {
             case CREEPER:
             case BLAZE:
             case SNOWMAN:
-            case IRON_GOLEM: {
+            case IRON_GOLEM:
                 restoreLiving((LivingEntity) entity);
                 return entity;
-            }
             // END LIVING //
         }
     }
 
-    private byte getOrdinal(final Object[] list, final Object value) {
+    private byte getOrdinal(Object[] list, Object value) {
         for (byte i = 0; i < list.length; i++) {
             if (list[i].equals(value)) {
                 return i;

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

@@ -1,4 +1,4 @@
-package com.intellectualcrafters.plot.object.entity;
+package com.plotsquared.bukkit.object.entity;
 
 public class HorseStats {
     public double jump;

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

@@ -0,0 +1,146 @@
+package com.plotsquared.bukkit.object.schematic;
+
+import com.intellectualcrafters.jnbt.ByteTag;
+import com.intellectualcrafters.jnbt.CompoundTag;
+import com.intellectualcrafters.jnbt.ListTag;
+import com.intellectualcrafters.jnbt.ShortTag;
+import com.intellectualcrafters.jnbt.Tag;
+import com.intellectualcrafters.plot.object.schematic.ItemType;
+import com.intellectualcrafters.plot.util.MathMan;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.ItemStack;
+
+public class StateWrapper {
+
+    public BlockState state = null;
+    public CompoundTag tag = null;
+
+    public StateWrapper(BlockState state) {
+        this.state = state;
+    }
+
+    public StateWrapper(CompoundTag tag) {
+        this.tag = tag;
+    }
+
+    public boolean restoreTag(String worldName, int x, int y, int z) {
+        if (this.tag == null) {
+            return false;
+        }
+        switch (tag.getString("id").toLowerCase()) {
+            case "chest": {
+                List<Tag> itemsTag = this.tag.getListTag("Items").getValue();
+                int length = itemsTag.size();
+                short[] ids = new short[length];
+                byte[] datas = new byte[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;
+                    short id = itemComp.getShort("id");
+                    String idStr = itemComp.getString("id");
+                    if (idStr != null && !MathMan.isInteger(idStr)) {
+                        idStr = idStr.split(":")[1].toLowerCase();
+                        id = (short) ItemType.getId(idStr);
+                    }
+                    ids[i] = id;
+                    datas[i] = (byte) itemComp.getShort("Damage");
+                    amounts[i] = itemComp.getByte("Count");
+                    slots[i] = itemComp.getByte("Slot");
+                }
+                World world = BukkitUtil.getWorld(worldName);
+                Block block = world.getBlockAt(x, y, z);
+                if (block == null) {
+                    return false;
+                }
+                BlockState state = block.getState();
+                if (state instanceof InventoryHolder) {
+                    InventoryHolder holder = (InventoryHolder) state;
+                    Inventory inv = holder.getInventory();
+                    for (int i = 0; i < ids.length; i++) {
+                        ItemStack item = new ItemStack(ids[i], amounts[i], datas[i]);
+                        inv.addItem(item);
+                    }
+                    state.update(true);
+                    return true;
+                } else {
+                }
+            }
+        }
+        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("Items", 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("Slot", (byte) i));
+                tags.add(new CompoundTag(tagData));
+            }
+        }
+        return tags;
+    }
+
+    /*
+     * TODO: Move this into the sponge module!
+     *
+    public Map<String, Tag> serializeItem(final org.spongepowered.api.item.inventory.ItemStack item) {
+        final Map<String, Tag> data = new HashMap<String, Tag>();
+        
+        // FIXME serialize sponge item
+        
+        return data;
+    }
+    */
+
+    public Map<String, Tag> serializeItem(ItemStack item) {
+        Map<String, Tag> data = new HashMap<>();
+        data.put("id", new ShortTag("id", (short) item.getTypeId()));
+        data.put("Damage", new ShortTag("Damage", item.getDurability()));
+        data.put("Count", new ByteTag("Count", (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 ShortTag("id", (short) entry.getKey().getId()));
+                enchantment.put("lvl", new ShortTag("lvl", entry.getValue().shortValue()));
+                enchantmentList.add(new CompoundTag(enchantment));
+            }
+            Map<String, Tag> auxData = new HashMap<>();
+            auxData.put("ench", new ListTag("ench", CompoundTag.class, enchantmentList));
+            data.put("tag", new CompoundTag("tag", auxData));
+        }
+        return data;
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/titles/DefaultTitle.java

@@ -5,12 +5,13 @@ import com.intellectualcrafters.plot.util.AbstractTitle;
 import com.plotsquared.bukkit.object.BukkitPlayer;
 
 public class DefaultTitle extends AbstractTitle {
+
     @Override
-    public void sendTitle(final PlotPlayer player, final String head, final String sub, int in, int delay, int out) {
+    public void sendTitle(PlotPlayer player, String head, String sub, int in, int delay, int out) {
         try {
-            final DefaultTitleManager title = new DefaultTitleManager(head, sub, in, delay, out);
+            DefaultTitleManager title = new DefaultTitleManager(head, sub, in, delay, out);
             title.send(((BukkitPlayer) player).player);
-        } catch (final Throwable e) {
+        } catch (Throwable e) {
             AbstractTitle.TITLE_CLASS = new DefaultTitle_183();
             AbstractTitle.TITLE_CLASS.sendTitle(player, head, sub, in, delay, out);
         }

Bukkit/src/main/java/com/plotsquared/bukkit/titles/DefaultTitleManager.java

@@ -0,0 +1,379 @@
+package com.plotsquared.bukkit.titles;
+
+import com.plotsquared.bukkit.chat.Reflection;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * [ PlotSquared DefaultTitleManager by Maxim Van de Wynckel ]
+ *
+ * @author Maxim Van de Wynckel
+ *
+ */
+public class DefaultTitleManager {
+
+    private static final Map<Class<?>, Class<?>> CORRESPONDING_TYPES = new HashMap<>();
+    /* Title packet */
+    private Class<?> packetTitle;
+    /* Title packet actions ENUM */
+    private Class<?> packetActions;
+    /* Chat serializer */
+    private Class<?> nmsChatSerializer;
+    private Class<?> chatBaseComponent;
+    /* Title text and color */
+    private String title = "";
+    private ChatColor titleColor = ChatColor.WHITE;
+    /* Subtitle text and color */
+    private String subtitle = "";
+    private ChatColor subtitleColor = ChatColor.WHITE;
+    /* Title timings */
+    private int fadeInTime = -1;
+    private int stayTime = -1;
+    private int fadeOutTime = -1;
+    private boolean ticks = false;
+
+    /**
+     * Create a new 1.8 title.
+     *
+     * @param title Title
+     * @throws ClassNotFoundException
+     */
+    public DefaultTitleManager(String title) throws ClassNotFoundException {
+        this.title = title;
+        loadClasses();
+    }
+
+    /**
+     * Create a new 1.8 title.
+     *
+     * @param title Title text
+     * @param subtitle Subtitle text
+     * @throws ClassNotFoundException
+     */
+    public DefaultTitleManager(String title, String subtitle) throws ClassNotFoundException {
+        this.title = title;
+        this.subtitle = subtitle;
+        loadClasses();
+    }
+
+    /**
+     * Copy 1.8 title.
+     *
+     * @param title Title
+     * @throws ClassNotFoundException
+     */
+    public DefaultTitleManager(DefaultTitleManager title) throws ClassNotFoundException {
+        // Copy title
+        this.title = title.title;
+        this.subtitle = title.subtitle;
+        this.titleColor = title.titleColor;
+        this.subtitleColor = title.subtitleColor;
+        this.fadeInTime = title.fadeInTime;
+        this.fadeOutTime = title.fadeOutTime;
+        this.stayTime = title.stayTime;
+        this.ticks = title.ticks;
+        loadClasses();
+    }
+
+    /**
+     * Create a new 1.8 title.
+     *
+     * @param title Title text
+     * @param subtitle Subtitle text
+     * @param fadeInTime Fade in time
+     * @param stayTime Stay on screen time
+     * @param fadeOutTime Fade out time
+     * @throws ClassNotFoundException
+     */
+    public DefaultTitleManager(String title, String subtitle, int fadeInTime, int stayTime, int fadeOutTime)
+            throws ClassNotFoundException {
+        this.title = title;
+        this.subtitle = subtitle;
+        this.fadeInTime = fadeInTime;
+        this.stayTime = stayTime;
+        this.fadeOutTime = fadeOutTime;
+        loadClasses();
+    }
+
+    private static boolean equalsTypeArray(Class<?>[] a, Class<?>[] o) {
+        if (a.length != o.length) {
+            return false;
+        }
+        for (int i = 0; i < a.length; i++) {
+            if (!a[i].equals(o[i]) && !a[i].isAssignableFrom(o[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Load spigot and NMS classes.
+     */
+    private void loadClasses() {
+        this.packetTitle = Reflection.getNMSClass("PacketPlayOutTitle");
+        this.packetActions = Reflection.getNMSClass("EnumTitleAction");
+        this.chatBaseComponent = Reflection.getNMSClass("IChatBaseComponent");
+        this.nmsChatSerializer = Reflection.getNMSClass("ChatSerializer");
+    }
+
+    /**
+     * Get title text.
+     *
+     * @return Title text
+     */
+    public String getTitle() {
+        return this.title;
+    }
+
+    /**
+     * Set title text.
+     *
+     * @param title Title
+     */
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    /**
+     * Get subtitle text.
+     *
+     * @return Subtitle text
+     */
+    public String getSubtitle() {
+        return this.subtitle;
+    }
+
+    /**
+     * Set subtitle text.
+     *
+     * @param subtitle Subtitle text
+     */
+    public void setSubtitle(String subtitle) {
+        this.subtitle = subtitle;
+    }
+
+    /**
+     * Set the title color.
+     *
+     * @param color Chat color
+     */
+    public void setTitleColor(ChatColor color) {
+        this.titleColor = color;
+    }
+
+    /**
+     * Set the subtitle color.
+     *
+     * @param color Chat color
+     */
+    public void setSubtitleColor(ChatColor color) {
+        this.subtitleColor = color;
+    }
+
+    /**
+     * Set title fade in time.
+     *
+     * @param time Time
+     */
+    public void setFadeInTime(int time) {
+        this.fadeInTime = time;
+    }
+
+    /**
+     * Set title fade out time.
+     *
+     * @param time Time
+     */
+    public void setFadeOutTime(int time) {
+        this.fadeOutTime = time;
+    }
+
+    /**
+     * Set title stay time.
+     *
+     * @param time Time
+     */
+    public void setStayTime(int time) {
+        this.stayTime = time;
+    }
+
+    /**
+     * Set timings to ticks.
+     */
+    public void setTimingsToTicks() {
+        this.ticks = true;
+    }
+
+    /**
+     * Set timings to seconds.
+     */
+    public void setTimingsToSeconds() {
+        this.ticks = false;
+    }
+
+    /**
+     * Send the title to a player.
+     *
+     * @param player Player
+     * @throws Exception
+     */
+    public void send(Player player) throws Exception {
+        if (this.packetTitle != null) {
+            // First reset previous settings
+            resetTitle(player);
+            // Send timings first
+            Object handle = getHandle(player);
+            Object connection = getField(handle.getClass(), "playerConnection").get(handle);
+            Object[] actions = this.packetActions.getEnumConstants();
+            Method sendPacket = getMethod(connection.getClass(), "sendPacket");
+            Object packet = this.packetTitle.getConstructor(this.packetActions, this.chatBaseComponent, Integer.TYPE, Integer.TYPE, Integer.TYPE)
+                    .newInstance(actions[2], null, this.fadeInTime * (this.ticks ? 1 : 20),
+                            this.stayTime * (this.ticks ? 1 : 20), this.fadeOutTime * (this.ticks ? 1 : 20));
+            // Send if set
+            if (this.fadeInTime != -1 && this.fadeOutTime != -1 && this.stayTime != -1) {
+                sendPacket.invoke(connection, packet);
+            }
+            // Send title
+            Object serialized = getMethod(this.nmsChatSerializer, "a", String.class).invoke(null,
+                    "{text:\"" + ChatColor.translateAlternateColorCodes('&', this.title) + "\",color:" + this.titleColor.name().toLowerCase() + "}");
+            packet = this.packetTitle.getConstructor(this.packetActions, this.chatBaseComponent).newInstance(actions[0], serialized);
+            sendPacket.invoke(connection, packet);
+            if (!this.subtitle.isEmpty()) {
+                // Send subtitle if present
+                serialized = getMethod(this.nmsChatSerializer, "a", String.class).invoke(null,
+                        "{text:\"" + ChatColor.translateAlternateColorCodes('&', this.subtitle) + "\",color:" + this.subtitleColor.name()
+                                .toLowerCase() + "}");
+                packet = this.packetTitle.getConstructor(this.packetActions, this.chatBaseComponent).newInstance(actions[1], serialized);
+                sendPacket.invoke(connection, packet);
+            }
+        }
+    }
+
+    /**
+     * Broadcast the title to all players.
+     *
+     * @throws Exception
+     */
+    public void broadcast() throws Exception {
+        for (Player p : Bukkit.getOnlinePlayers()) {
+            send(p);
+        }
+    }
+
+    /**
+     * Clear the title.
+     *
+     * @param player Player
+     * @throws Exception
+     */
+    public void clearTitle(Player player) throws Exception {
+        // Send timings first
+        Object handle = getHandle(player);
+        Object connection = getField(handle.getClass(), "playerConnection").get(handle);
+        Object[] actions = this.packetActions.getEnumConstants();
+        Method sendPacket = getMethod(connection.getClass(), "sendPacket");
+        Object packet = this.packetTitle.getConstructor(this.packetActions, this.chatBaseComponent).newInstance(actions[3], null);
+        sendPacket.invoke(connection, packet);
+    }
+
+    /**
+     * Reset the title settings.
+     *
+     * @param player Player
+     * @throws Exception
+     */
+    public void resetTitle(Player player) throws Exception {
+        // Send timings first
+        Object handle = getHandle(player);
+        Object connection = getField(handle.getClass(), "playerConnection").get(handle);
+        Object[] actions = this.packetActions.getEnumConstants();
+        Method sendPacket = getMethod(connection.getClass(), "sendPacket");
+        Object packet = this.packetTitle.getConstructor(this.packetActions, this.chatBaseComponent).newInstance(actions[4], null);
+        sendPacket.invoke(connection, packet);
+    }
+
+    private Class<?> getPrimitiveType(Class<?> clazz) {
+        return CORRESPONDING_TYPES.containsKey(clazz) ? CORRESPONDING_TYPES.get(clazz) : clazz;
+    }
+
+    private Class<?>[] toPrimitiveTypeArray(Class<?>[] classes) {
+        int a = classes != null ? classes.length : 0;
+        Class<?>[] types = new Class<?>[a];
+        for (int i = 0; i < a; i++) {
+            types[i] = getPrimitiveType(classes[i]);
+        }
+        return types;
+    }
+
+    private Object getHandle(Object obj) {
+        try {
+            return getMethod("getHandle", obj.getClass()).invoke(obj);
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+            return null;
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+            return null;
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    private Method getMethod(String name, Class<?> clazz, Class<?>... paramTypes) {
+        Class<?>[] t = toPrimitiveTypeArray(paramTypes);
+        for (Method m : clazz.getMethods()) {
+            Class<?>[] types = toPrimitiveTypeArray(m.getParameterTypes());
+            if (m.getName().equals(name) && equalsTypeArray(types, t)) {
+                return m;
+            }
+        }
+        return null;
+    }
+
+    private Field getField(Class<?> clazz, String name) {
+        try {
+            Field field = clazz.getDeclaredField(name);
+            field.setAccessible(true);
+            return field;
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return null;
+        } catch (SecurityException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    private Method getMethod(Class<?> clazz, String name, Class<?>... args) {
+        for (Method m : clazz.getMethods()) {
+            if (m.getName().equals(name) && (args.length == 0 || ClassListEqual(args, m.getParameterTypes()))) {
+                m.setAccessible(true);
+                return m;
+            }
+        }
+        return null;
+    }
+
+    private boolean ClassListEqual(Class<?>[] l1, Class<?>[] l2) {
+        if (l1.length != l2.length) {
+            return false;
+        }
+        boolean equal = true;
+        for (int i = 0; i < l1.length; i++) {
+            if (l1[i] != l2[i]) {
+                equal = false;
+                break;
+            }
+        }
+        return equal;
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/titles/DefaultTitleManager_183.java

@@ -0,0 +1,373 @@
+package com.plotsquared.bukkit.titles;
+
+import com.plotsquared.bukkit.chat.Reflection;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * [ PlotSquared DefaultTitleManager by Maxim Van de Wynckel ]
+ *
+ * @version 1.1.0
+ * @author Maxim Van de Wynckel
+ *
+ */
+public class DefaultTitleManager_183 {
+
+    private static final Map<Class<?>, Class<?>> CORRESPONDING_TYPES = new HashMap<>();
+    /* Title packet */
+    private Class<?> packetTitle;
+    /* Title packet actions ENUM */
+    private Class<?> packetActions;
+    /* Chat serializer */
+    private Class<?> nmsChatSerializer;
+    private Class<?> chatBaseComponent;
+    /* Title text and color */
+    private String title = "";
+    private ChatColor titleColor = ChatColor.WHITE;
+    /* Subtitle text and color */
+    private String subtitle = "";
+    private ChatColor subtitleColor = ChatColor.WHITE;
+    /* Title timings */
+    private int fadeInTime = -1;
+    private int stayTime = -1;
+    private int fadeOutTime = -1;
+    private boolean ticks = false;
+
+    /**
+     * Create a new 1.8 title
+     *
+     * @param title
+     *            Title
+     * @throws ClassNotFoundException
+     */
+    public DefaultTitleManager_183(String title) throws ClassNotFoundException {
+        this.title = title;
+        loadClasses();
+    }
+
+    /**
+     * Create a new 1.8 title.
+     *
+     * @param title Title text
+     * @param subtitle Subtitle text
+     * @throws ClassNotFoundException
+     */
+    public DefaultTitleManager_183(String title, String subtitle) throws ClassNotFoundException {
+        this.title = title;
+        this.subtitle = subtitle;
+        loadClasses();
+    }
+
+    /**
+     * Copy 1.8 title.
+     *
+     * @param title Title
+     * @throws ClassNotFoundException
+     */
+    public DefaultTitleManager_183(DefaultTitleManager_183 title) throws ClassNotFoundException {
+        // Copy title
+        this.title = title.title;
+        this.subtitle = title.subtitle;
+        this.titleColor = title.titleColor;
+        this.subtitleColor = title.subtitleColor;
+        this.fadeInTime = title.fadeInTime;
+        this.fadeOutTime = title.fadeOutTime;
+        this.stayTime = title.stayTime;
+        this.ticks = title.ticks;
+        loadClasses();
+    }
+
+    /**
+     * Create a new 1.8 title.
+     *
+     * @param title Title text
+     * @param subtitle Subtitle text
+     * @param fadeInTime Fade in time
+     * @param stayTime Stay on screen time
+     * @param fadeOutTime Fade out time
+     * @throws ClassNotFoundException
+     */
+    public DefaultTitleManager_183(String title, String subtitle, int fadeInTime, int stayTime, int fadeOutTime) throws ClassNotFoundException {
+        this.title = title;
+        this.subtitle = subtitle;
+        this.fadeInTime = fadeInTime;
+        this.stayTime = stayTime;
+        this.fadeOutTime = fadeOutTime;
+        loadClasses();
+    }
+
+    private static boolean equalsTypeArray(Class<?>[] a, Class<?>[] o) {
+        if (a.length != o.length) {
+            return false;
+        }
+        for (int i = 0; i < a.length; i++) {
+            if (!a[i].equals(o[i]) && !a[i].isAssignableFrom(o[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Load spigot and NMS classes.
+     */
+    private void loadClasses() {
+        this.packetTitle = Reflection.getNMSClass("PacketPlayOutTitle");
+        this.chatBaseComponent = Reflection.getNMSClass("IChatBaseComponent");
+        this.packetActions = Reflection.getNMSClass("PacketPlayOutTitle$EnumTitleAction");
+        this.nmsChatSerializer = Reflection.getNMSClass("IChatBaseComponent$ChatSerializer");
+
+    }
+
+    /**
+     * Get title text.
+     *
+     * @return Title text
+     */
+    public String getTitle() {
+        return this.title;
+    }
+
+    /**
+     * Set title text.
+     *
+     * @param title Title
+     */
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    /**
+     * Get subtitle text.
+     *
+     * @return Subtitle text
+     */
+    public String getSubtitle() {
+        return this.subtitle;
+    }
+
+    /**
+     * Set subtitle text.
+     *
+     * @param subtitle Subtitle text
+     */
+    public void setSubtitle(String subtitle) {
+        this.subtitle = subtitle;
+    }
+
+    /**
+     * Set the title color.
+     *
+     * @param color Chat color
+     */
+    public void setTitleColor(ChatColor color) {
+        this.titleColor = color;
+    }
+
+    /**
+     * Set the subtitle color.
+     *
+     * @param color Chat color
+     */
+    public void setSubtitleColor(ChatColor color) {
+        this.subtitleColor = color;
+    }
+
+    /**
+     * Set title fade in time.
+     *
+     * @param time
+     *            Time
+     */
+    public void setFadeInTime(int time) {
+        this.fadeInTime = time;
+    }
+
+    /**
+     * Set title fade out time.
+     *
+     * @param time Time
+     */
+    public void setFadeOutTime(int time) {
+        this.fadeOutTime = time;
+    }
+
+    /**
+     * Set title stay time.
+     *
+     * @param time Time
+     */
+    public void setStayTime(int time) {
+        this.stayTime = time;
+    }
+
+    /**
+     * Set timings to ticks.
+     */
+    public void setTimingsToTicks() {
+        this.ticks = true;
+    }
+
+    /**
+     * Set timings to seconds.
+     */
+    public void setTimingsToSeconds() {
+        this.ticks = false;
+    }
+
+    /**
+     * Send the title to a player.
+     *
+     * @param player Player
+     * @throws Exception
+     */
+    public void send(Player player) throws Exception {
+        if (this.packetTitle != null) {
+            // First reset previous settings
+            resetTitle(player);
+            // Send timings first
+            Object handle = getHandle(player);
+            Object connection = getField(handle.getClass(), "playerConnection").get(handle);
+            Object[] actions = this.packetActions.getEnumConstants();
+            Method sendPacket = getMethod(connection.getClass(), "sendPacket");
+            Object packet = this.packetTitle
+                    .getConstructor(this.packetActions, this.chatBaseComponent, Integer.TYPE, Integer.TYPE, Integer.TYPE)
+                    .newInstance(actions[2], null,
+                            this.fadeInTime * (this.ticks ? 1 : 20),
+                            this.stayTime * (this.ticks ? 1 : 20), this.fadeOutTime * (this.ticks ? 1 : 20));
+            // Send if set
+            if ((this.fadeInTime != -1) && (this.fadeOutTime != -1) && (this.stayTime != -1)) {
+                sendPacket.invoke(connection, packet);
+            }
+            // Send title
+            Object serialized = getMethod(this.nmsChatSerializer, "a", String.class).invoke(null,
+                    "{text:\"" + ChatColor.translateAlternateColorCodes('&', this.title) + "\",color:" + this.titleColor.name().toLowerCase() + "}");
+            packet = this.packetTitle.getConstructor(this.packetActions, this.chatBaseComponent).newInstance(actions[0], serialized);
+            sendPacket.invoke(connection, packet);
+            if (!this.subtitle.isEmpty()) {
+                // Send subtitle if present
+                serialized = getMethod(this.nmsChatSerializer, "a", String.class).invoke(null,
+                        "{text:\"" + ChatColor.translateAlternateColorCodes('&', this.subtitle) + "\",color:" + this.subtitleColor.name()
+                                .toLowerCase() + "}");
+                packet = this.packetTitle.getConstructor(this.packetActions, this.chatBaseComponent).newInstance(actions[1], serialized);
+                sendPacket.invoke(connection, packet);
+            }
+        }
+    }
+
+    /**
+     * Broadcast the title to all players.
+     * @throws Exception
+     */
+    public void broadcast() throws Exception {
+        for (Player p : Bukkit.getOnlinePlayers()) {
+            send(p);
+        }
+    }
+
+    /**
+     * Clear the title.
+     *
+     * @param player Player
+     * @throws Exception
+     */
+    public void clearTitle(Player player) throws Exception {
+        // Send timings first
+        Object handle = getHandle(player);
+        Object connection = getField(handle.getClass(), "playerConnection").get(handle);
+        Object[] actions = this.packetActions.getEnumConstants();
+        Method sendPacket = getMethod(connection.getClass(), "sendPacket");
+        Object packet = this.packetTitle.getConstructor(this.packetActions, this.chatBaseComponent).newInstance(actions[3], null);
+        sendPacket.invoke(connection, packet);
+    }
+
+    /**
+     * Reset the title settings.
+     *
+     * @param player Player
+     * @throws Exception
+     */
+    public void resetTitle(Player player) throws Exception {
+        // Send timings first
+        Object handle = getHandle(player);
+        Object connection = getField(handle.getClass(), "playerConnection").get(handle);
+        Object[] actions = this.packetActions.getEnumConstants();
+        Method sendPacket = getMethod(connection.getClass(), "sendPacket");
+        Object packet = this.packetTitle.getConstructor(this.packetActions, this.chatBaseComponent).newInstance(actions[4], null);
+        sendPacket.invoke(connection, packet);
+    }
+
+    private Class<?> getPrimitiveType(Class<?> clazz) {
+        return CORRESPONDING_TYPES.containsKey(clazz) ? CORRESPONDING_TYPES.get(clazz) : clazz;
+    }
+
+    private Class<?>[] toPrimitiveTypeArray(Class<?>[] classes) {
+        int a = classes != null ? classes.length : 0;
+        Class<?>[] types = new Class<?>[a];
+        for (int i = 0; i < a; i++) {
+            types[i] = getPrimitiveType(classes[i]);
+        }
+        return types;
+    }
+
+    private Object getHandle(Object obj) {
+        try {
+            return getMethod("getHandle", obj.getClass()).invoke(obj);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    private Method getMethod(String name, Class<?> clazz, Class<?>... paramTypes) {
+        Class<?>[] t = toPrimitiveTypeArray(paramTypes);
+        for (Method m : clazz.getMethods()) {
+            Class<?>[] types = toPrimitiveTypeArray(m.getParameterTypes());
+            if (m.getName().equals(name) && equalsTypeArray(types, t)) {
+                return m;
+            }
+        }
+        return null;
+    }
+
+    private Field getField(Class<?> clazz, String name) {
+        try {
+            Field field = clazz.getDeclaredField(name);
+            field.setAccessible(true);
+            return field;
+        } catch (NoSuchFieldException | SecurityException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    private Method getMethod(Class<?> clazz, String name, Class<?>... args) {
+        for (Method m : clazz.getMethods()) {
+            if (m.getName().equals(name) && ((args.length == 0) || ClassListEqual(args, m.getParameterTypes()))) {
+                m.setAccessible(true);
+                return m;
+            }
+        }
+        return null;
+    }
+
+    private boolean ClassListEqual(Class<?>[] l1, Class<?>[] l2) {
+        if (l1.length != l2.length) {
+            return false;
+        }
+        boolean equal = true;
+        for (int i = 0; i < l1.length; i++) {
+            if (l1[i] != l2[i]) {
+                equal = false;
+                break;
+            }
+        }
+        return equal;
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/titles/DefaultTitle_183.java

@@ -5,12 +5,13 @@ import com.intellectualcrafters.plot.util.AbstractTitle;
 import com.plotsquared.bukkit.object.BukkitPlayer;
 
 public class DefaultTitle_183 extends AbstractTitle {
+
     @Override
-    public void sendTitle(final PlotPlayer player, final String head, final String sub, int in, int delay, int out) {
+    public void sendTitle(PlotPlayer player, String head, String sub, int in, int delay, int out) {
         try {
-            final DefaultTitleManager_183 title = new DefaultTitleManager_183(head, sub, in, delay, out);
+            DefaultTitleManager_183 title = new DefaultTitleManager_183(head, sub, in, delay, out);
             title.send(((BukkitPlayer) player).player);
-        } catch (final Throwable e) {
+        } catch (Throwable e) {
             AbstractTitle.TITLE_CLASS = new HackTitle();
             AbstractTitle.TITLE_CLASS.sendTitle(player, head, sub, in, delay, out);
         }

Bukkit/src/main/java/com/plotsquared/bukkit/titles/DefaultTitle_19.java

@@ -0,0 +1,27 @@
+package com.plotsquared.bukkit.titles;
+
+import com.intellectualcrafters.plot.object.PlotPlayer;
+import com.intellectualcrafters.plot.util.AbstractTitle;
+import com.intellectualcrafters.plot.util.TaskManager;
+import com.plotsquared.bukkit.object.BukkitPlayer;
+import org.bukkit.entity.Player;
+
+public class DefaultTitle_19 extends AbstractTitle {
+
+    @Override
+    public void sendTitle(PlotPlayer player, String head, String sub, int in, int delay, int out) {
+        try {
+            final Player playerObj = ((BukkitPlayer) player).player;
+            playerObj.sendTitle(head, sub);
+            TaskManager.runTaskLater(new Runnable() {
+                @Override
+                public void run() {
+                    playerObj.sendTitle("", "");
+                }
+            }, delay * 20);
+        } catch (Throwable e) {
+            AbstractTitle.TITLE_CLASS = new DefaultTitle();
+            AbstractTitle.TITLE_CLASS.sendTitle(player, head, sub, in, delay, out);
+        }
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/titles/HackTitle.java

@@ -7,12 +7,13 @@ import com.intellectualcrafters.plot.util.AbstractTitle;
 import com.plotsquared.bukkit.object.BukkitPlayer;
 
 public class HackTitle extends AbstractTitle {
+
     @Override
-    public void sendTitle(final PlotPlayer player, final String head, final String sub, int in, int delay, int out) {
+    public void sendTitle(PlotPlayer player, String head, String sub, int in, int delay, int out) {
         try {
-            final HackTitleManager title = new HackTitleManager(head, sub, in, delay, out);
+            HackTitleManager title = new HackTitleManager(head, sub, in, delay, out);
             title.send(((BukkitPlayer) player).player);
-        } catch (final Throwable e) {
+        } catch (Throwable e) {
             PS.debug("&cYour server version does not support titles!");
             Settings.TITLES = false;
             AbstractTitle.TITLE_CLASS = null;

Bukkit/src/main/java/com/plotsquared/bukkit/titles/HackTitleManager.java

@@ -0,0 +1,420 @@
+package com.plotsquared.bukkit.titles;
+
+import com.plotsquared.bukkit.chat.Reflection;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Minecraft 1.8 Title.
+ *
+ * @version 1.0.4
+ * @author Maxim Van de Wynckel
+ */
+public class HackTitleManager {
+
+    private static final Map<Class<?>, Class<?>> CORRESPONDING_TYPES = new HashMap<>();
+    /* Title packet */
+    private Class<?> packetTitle;
+    /* Title packet actions ENUM */
+    private Class<?> packetActions;
+    /* Chat serializer */
+    private Class<?> nmsChatSerializer;
+    /* Title text and color */
+    private String title = "";
+    private ChatColor titleColor = ChatColor.WHITE;
+    /* Subtitle text and color */
+    private String subtitle = "";
+    private ChatColor subtitleColor = ChatColor.WHITE;
+    /* Title timings. */
+    private int fadeInTime = -1;
+    private int stayTime = -1;
+    private int fadeOutTime = -1;
+    private boolean ticks = false;
+
+    /**
+     * Create a new 1.8 title.
+     *
+     * @param title Title
+     * @throws ClassNotFoundException NMS Error.
+     */
+    public HackTitleManager(String title) throws ClassNotFoundException {
+        this.title = title;
+        loadClasses();
+    }
+
+    /**
+     * Create a new 1.8 title.
+     *
+     * @param title Title text
+     * @param subtitle Subtitle text
+     * @throws ClassNotFoundException NMS Error
+     */
+    public HackTitleManager(String title, String subtitle) throws ClassNotFoundException {
+        this.title = title;
+        this.subtitle = subtitle;
+        loadClasses();
+    }
+
+    /**
+     * Copy 1.8 title.
+     *
+     * @param title Title
+     * @throws ClassNotFoundException NMS Error
+     */
+    public HackTitleManager(HackTitleManager title) throws ClassNotFoundException {
+        // Copy title
+        this.title = title.title;
+        this.subtitle = title.subtitle;
+        this.titleColor = title.titleColor;
+        this.subtitleColor = title.subtitleColor;
+        this.fadeInTime = title.fadeInTime;
+        this.fadeOutTime = title.fadeOutTime;
+        this.stayTime = title.stayTime;
+        this.ticks = title.ticks;
+        loadClasses();
+    }
+
+    /**
+     * Create a new 1.8 title.
+     *
+     * @param title Title text
+     * @param subtitle Subtitle text
+     * @param fadeInTime Fade in time
+     * @param stayTime Stay on screen time
+     * @param fadeOutTime Fade out time
+     * @throws ClassNotFoundException NMS error
+     */
+    public HackTitleManager(String title, String subtitle, int fadeInTime, int stayTime, int fadeOutTime) throws ClassNotFoundException {
+        this.title = title;
+        this.subtitle = subtitle;
+        this.fadeInTime = fadeInTime;
+        this.stayTime = stayTime;
+        this.fadeOutTime = fadeOutTime;
+        loadClasses();
+    }
+
+    private static boolean equalsTypeArray(Class<?>[] a, Class<?>[] o) {
+        if (a.length != o.length) {
+            return false;
+        }
+        for (int i = 0; i < a.length; i++) {
+            if (!a[i].equals(o[i]) && !a[i].isAssignableFrom(o[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Load spigot and NMS classes.
+     */
+    private void loadClasses() {
+        this.packetTitle = getClass("org.spigotmc.ProtocolInjector$PacketTitle");
+        this.packetActions = getClass("org.spigotmc.ProtocolInjector$PacketTitle$Action");
+        this.nmsChatSerializer = Reflection.getNMSClass("ChatSerializer");
+    }
+
+    /**
+     * Get title text.
+     *
+     * @return Title text
+     */
+    public String getTitle() {
+        return this.title;
+    }
+
+    /**
+     * Set title text.
+     *
+     * @param title Title
+     */
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    /**
+     * Get subtitle text.
+     *
+     * @return Subtitle text
+     */
+    public String getSubtitle() {
+        return this.subtitle;
+    }
+
+    /**
+     * Set subtitle text.
+     *
+     * @param subtitle Subtitle text
+     */
+    public void setSubtitle(String subtitle) {
+        this.subtitle = subtitle;
+    }
+
+    /**
+     * Set the title color.
+     *
+     * @param color Chat color
+     */
+    public void setTitleColor(ChatColor color) {
+        this.titleColor = color;
+    }
+
+    /**
+     * Set the subtitle color.
+     *
+     * @param color Chat color
+     */
+    public void setSubtitleColor(ChatColor color) {
+        this.subtitleColor = color;
+    }
+
+    /**
+     * Set title fade in time.
+     *
+     * @param time Time
+     */
+    public void setFadeInTime(int time) {
+        this.fadeInTime = time;
+    }
+
+    /**
+     * Set title fade out time.
+     *
+     * @param time Time
+     */
+    public void setFadeOutTime(int time) {
+        this.fadeOutTime = time;
+    }
+
+    /**
+     * Set title stay time.
+     *
+     * @param time Time
+     */
+    public void setStayTime(int time) {
+        this.stayTime = time;
+    }
+
+    /**
+     * Set timings to ticks.
+     */
+    public void setTimingsToTicks() {
+        this.ticks = true;
+    }
+
+    /**
+     * Set timings to seconds.
+     */
+    public void setTimingsToSeconds() {
+        this.ticks = false;
+    }
+
+    /**
+     * Send the title to a player.
+     *
+     * @param player Player
+     * @throws Exception on NMS error
+     */
+    public void send(Player player) throws Exception {
+        if ((getProtocolVersion(player) >= 47) && isSpigot() && (this.packetTitle != null)) {
+            // First reset previous settings
+            resetTitle(player);
+            // Send timings first
+            Object handle = getHandle(player);
+            Object connection = getField(handle.getClass(), "playerConnection").get(handle);
+            Object[] actions = this.packetActions.getEnumConstants();
+            Method sendPacket = getMethod(connection.getClass(), "sendPacket");
+            Object packet = this.packetTitle.getConstructor(this.packetActions, Integer.TYPE, Integer.TYPE, Integer.TYPE).newInstance(actions[2],
+                    this.fadeInTime * (this.ticks ? 1 : 20),
+                    this.stayTime * (this.ticks ? 1 : 20),
+                    this.fadeOutTime * (this.ticks ? 1 : 20));
+            // Send if set
+            if ((this.fadeInTime != -1) && (this.fadeOutTime != -1) && (this.stayTime != -1)) {
+                sendPacket.invoke(connection, packet);
+            }
+            // Send title
+            Object serialized = getMethod(this.nmsChatSerializer, "a", String.class).invoke(null,
+                    "{text:\"" + ChatColor.translateAlternateColorCodes('&', this.title) + "\",color:" + this.titleColor.name().toLowerCase() + "}");
+            packet = this.packetTitle.getConstructor(this.packetActions, Reflection.getNMSClass("IChatBaseComponent"))
+                    .newInstance(actions[0], serialized);
+            sendPacket.invoke(connection, packet);
+            if (!this.subtitle.isEmpty()) {
+                // Send subtitle if present
+                serialized = getMethod(this.nmsChatSerializer, "a", String.class).invoke(null,
+                        "{text:\"" + ChatColor.translateAlternateColorCodes('&', this.subtitle) + "\",color:" + this.subtitleColor.name()
+                                .toLowerCase() + "}");
+                packet = this.packetTitle.getConstructor(this.packetActions, Reflection.getNMSClass("IChatBaseComponent"))
+                        .newInstance(actions[1], serialized);
+                sendPacket.invoke(connection, packet);
+            }
+        }
+    }
+
+    /**
+     * Broadcast the title to all players.
+     * @throws Exception on NMS Error
+     */
+    public void broadcast() throws Exception {
+        for (Player p : Bukkit.getOnlinePlayers()) {
+            send(p);
+        }
+    }
+
+    /**
+     * Clear the title.
+     *
+     * @param player Player
+     * @throws Exception on NMS Error
+     */
+    public void clearTitle(Player player) throws Exception {
+        if ((getProtocolVersion(player) >= 47) && isSpigot()) {
+            // Send timings first
+            Object handle = getHandle(player);
+            Object connection = getField(handle.getClass(), "playerConnection").get(handle);
+            Object[] actions = this.packetActions.getEnumConstants();
+            Method sendPacket = getMethod(connection.getClass(), "sendPacket");
+            Object packet = this.packetTitle.getConstructor(this.packetActions).newInstance(actions[3]);
+            sendPacket.invoke(connection, packet);
+        }
+    }
+
+    /**
+     * Reset the title settings.
+     *
+     * @param player Player
+     * @throws Exception on NMS error.
+     */
+    public void resetTitle(Player player) throws Exception {
+        if ((getProtocolVersion(player) >= 47) && isSpigot()) {
+            // Send timings first
+            Object handle = getHandle(player);
+            Object connection = getField(handle.getClass(), "playerConnection").get(handle);
+            Object[] actions = this.packetActions.getEnumConstants();
+            Method sendPacket = getMethod(connection.getClass(), "sendPacket");
+            Object packet = this.packetTitle.getConstructor(this.packetActions).newInstance(actions[4]);
+            sendPacket.invoke(connection, packet);
+        }
+    }
+
+    /**
+     * Get the protocol version of the player.
+     *
+     * @param player Player
+     * @return Protocol version
+     * @throws Exception on NMS Error
+     */
+    private int getProtocolVersion(Player player) throws Exception {
+        Object handle = getHandle(player);
+        Object connection = getField(handle.getClass(), "playerConnection").get(handle);
+        Object networkManager = getValue("networkManager", connection);
+        return (Integer) getMethod("getVersion", networkManager.getClass()).invoke(networkManager);
+    }
+
+    /**
+     * Check if running spigot.
+     *
+     * @return Spigot
+     */
+    private boolean isSpigot() {
+        return Bukkit.getVersion().contains("Spigot");
+    }
+
+    /**
+     * Get class by url.
+     *
+     * @param namespace Namespace url
+     * @return Class
+     */
+    private Class<?> getClass(String namespace) {
+        try {
+            return Class.forName(namespace);
+        } catch (ClassNotFoundException ignored) {
+        }
+        return null;
+    }
+
+    private Field getField(String name, Class<?> clazz) throws Exception {
+        return clazz.getDeclaredField(name);
+    }
+
+    private Object getValue(String name, Object obj) throws Exception {
+        Field f = getField(name, obj.getClass());
+        f.setAccessible(true);
+        return f.get(obj);
+    }
+
+    private Class<?> getPrimitiveType(Class<?> clazz) {
+        return CORRESPONDING_TYPES.containsKey(clazz) ? CORRESPONDING_TYPES.get(clazz) : clazz;
+    }
+
+    private Class<?>[] toPrimitiveTypeArray(Class<?>[] classes) {
+        int a = classes != null ? classes.length : 0;
+        Class<?>[] types = new Class<?>[a];
+        for (int i = 0; i < a; i++) {
+            types[i] = getPrimitiveType(classes[i]);
+        }
+        return types;
+    }
+
+    private Object getHandle(Object obj) {
+        try {
+            return getMethod("getHandle", obj.getClass()).invoke(obj);
+        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    private Method getMethod(String name, Class<?> clazz, Class<?>... paramTypes) {
+        Class<?>[] t = toPrimitiveTypeArray(paramTypes);
+        for (Method m : clazz.getMethods()) {
+            Class<?>[] types = toPrimitiveTypeArray(m.getParameterTypes());
+            if (m.getName().equals(name) && equalsTypeArray(types, t)) {
+                return m;
+            }
+        }
+        return null;
+    }
+
+    private Field getField(Class<?> clazz, String name) {
+        try {
+            Field field = clazz.getDeclaredField(name);
+            field.setAccessible(true);
+            return field;
+        } catch (SecurityException | NoSuchFieldException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    private Method getMethod(Class<?> clazz, String name, Class<?>... args) {
+        for (Method m : clazz.getMethods()) {
+            if (m.getName().equals(name) && ((args.length == 0) || classListEqual(args, m.getParameterTypes()))) {
+                m.setAccessible(true);
+                return m;
+            }
+        }
+        return null;
+    }
+
+    private boolean classListEqual(Class<?>[] l1, Class<?>[] l2) {
+        if (l1.length != l2.length) {
+            return false;
+        }
+        boolean equal = true;
+        for (int i = 0; i < l1.length; i++) {
+            if (l1[i] != l2[i]) {
+                equal = false;
+                break;
+            }
+        }
+        return equal;
+    }
+}

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

@@ -0,0 +1,60 @@
+package com.plotsquared.bukkit.util;
+
+import com.intellectualcrafters.plot.config.C;
+import com.intellectualcrafters.plot.object.ConsolePlayer;
+import com.intellectualcrafters.plot.object.PlotMessage;
+import com.intellectualcrafters.plot.object.PlotPlayer;
+import com.intellectualcrafters.plot.util.ChatManager;
+import com.plotsquared.bukkit.chat.FancyMessage;
+import com.plotsquared.bukkit.object.BukkitPlayer;
+import org.bukkit.ChatColor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BukkitChatManager extends ChatManager<FancyMessage> {
+
+    @Override
+    public FancyMessage builder() {
+        return new FancyMessage("");
+    }
+
+    @Override
+    public void color(PlotMessage m, String color) {
+        m.$(this).color(ChatColor.getByChar(C.color(color).substring(1)));
+    }
+
+    @Override
+    public void tooltip(PlotMessage m, PlotMessage... tooltips) {
+        List<FancyMessage> lines = new ArrayList<>();
+        for (PlotMessage tooltip : tooltips) {
+            lines.add(tooltip.$(this));
+        }
+        m.$(this).formattedTooltip(lines);
+    }
+
+    @Override
+    public void command(PlotMessage m, String command) {
+        m.$(this).command(command);
+    }
+
+    @Override
+    public void text(PlotMessage m, String text) {
+        m.$(this).then(ChatColor.stripColor(text));
+    }
+
+    @Override
+    public void send(PlotMessage m, PlotPlayer player) {
+        if (ConsolePlayer.isConsole(player)) {
+            player.sendMessage(m.$(this).toOldMessageFormat());
+        } else {
+            m.$(this).send(((BukkitPlayer) player).player);
+        }
+    }
+
+    @Override
+    public void suggest(PlotMessage m, String command) {
+        m.$(this).suggest(command);
+    }
+
+}

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

@@ -0,0 +1,77 @@
+package com.plotsquared.bukkit.util;
+
+import com.intellectualcrafters.plot.commands.MainCommand;
+import com.intellectualcrafters.plot.object.ConsolePlayer;
+import com.intellectualcrafters.plot.object.PlotPlayer;
+import com.plotsquared.bukkit.commands.DebugUUID;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+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(final CommandSender commandSender, org.bukkit.command.Command command, final String commandLabel, String[] args) {
+        if (commandSender instanceof Player) {
+            return MainCommand.onCommand(BukkitUtil.getPlayer((Player) commandSender), args);
+        }
+        if (commandSender.getClass() == Bukkit.getConsoleSender().getClass()) {
+            return MainCommand.onCommand(ConsolePlayer.getConsole(), args);
+        }
+        @SuppressWarnings("deprecation")
+        ConsolePlayer sender = new ConsolePlayer() {
+            @Override
+            public void sendMessage(String message) {
+                commandSender.sendMessage(commandLabel);
+            }
+
+            @Override
+            public boolean hasPermission(String permission) {
+                return commandSender.hasPermission(commandLabel);
+            }
+
+            @Override
+            public String getName() {
+                if (commandSender.getName().equals("CONSOLE")) {
+                    return "*";
+                }
+                return commandSender.getName();
+            }
+        };
+        sender.teleport(ConsolePlayer.getConsole().getLocationFull());
+        boolean result = MainCommand.onCommand(sender, args);
+        ConsolePlayer.getConsole().teleport(sender.getLocationFull());
+        return result;
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender commandSender, org.bukkit.command.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.size() == 0 ? null : result;
+    }
+}

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

@@ -1,94 +1,88 @@
 package com.plotsquared.bukkit.util;
 
-import net.milkbowl.vault.economy.Economy;
-import net.milkbowl.vault.permission.Permission;
-
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.bukkit.plugin.RegisteredServiceProvider;
-
 import com.intellectualcrafters.plot.object.OfflinePlotPlayer;
 import com.intellectualcrafters.plot.object.PlotPlayer;
 import com.intellectualcrafters.plot.util.EconHandler;
 import com.plotsquared.bukkit.object.BukkitOfflinePlayer;
+import com.plotsquared.bukkit.object.BukkitPlayer;
+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 Economy getEconomy() {
         init();
-        return econ;
+        return this.econ;
     }
-    
+
     public Permission getPermissions() {
         init();
-        return perms;
+        return this.perms;
     }
-    
+
     public boolean init() {
-        if (econ == null || perms == null) {
+        if (this.econ == null || this.perms == null) {
             setupPermissions();
             setupEconomy();
         }
-        return econ != null && perms != null;
-    }
-    
-    private boolean setupPermissions()
-    {
-        RegisteredServiceProvider<Permission> permissionProvider = Bukkit.getServer().getServicesManager().getRegistration(net.milkbowl.vault.permission.Permission.class);
-        if (permissionProvider != null) {
-            perms = permissionProvider.getProvider();
-        }
-        return (perms != null);
+        return this.econ != null && this.perms != null;
     }
 
-    private boolean setupEconomy()
-    {
-        RegisteredServiceProvider<Economy> economyProvider = Bukkit.getServer().getServicesManager().getRegistration(net.milkbowl.vault.economy.Economy.class);
-        if (economyProvider != null) {
-            econ = economyProvider.getProvider();
+    private boolean setupPermissions() {
+        RegisteredServiceProvider<Permission> permissionProvider = Bukkit.getServer().getServicesManager().getRegistration(Permission.class);
+        if (permissionProvider != null) {
+            this.perms = permissionProvider.getProvider();
         }
-        return (econ != null);
+        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 econ.getBalance(player.getName());
+            return this.econ.getBalance(((BukkitPlayer) player).player);
         }
         return bal;
     }
 
     @Override
     public void withdrawMoney(PlotPlayer player, double amount) {
-        econ.withdrawPlayer(player.getName(), amount);
+        this.econ.withdrawPlayer(((BukkitPlayer) player).player, amount);
     }
 
     @Override
     public void depositMoney(PlotPlayer player, double amount) {
-        econ.depositPlayer(player.getName(), amount);
+        this.econ.depositPlayer(((BukkitPlayer) player).player, amount);
     }
 
     @Override
     public void depositMoney(OfflinePlotPlayer player, double amount) {
-        econ.depositPlayer(((BukkitOfflinePlayer) player).player, amount);
+        this.econ.depositPlayer(((BukkitOfflinePlayer) player).player, amount);
     }
 
     @Override
-    public void setPermission(String player, String perm, boolean value) {
-        if (value) {
-            perms.playerAdd((World) null, player, perm);
-        }
-        else {
-            perms.playerRemove((World) null, player, perm);
-        }
+    public boolean hasPermission(String world, String player, String perm) {
+        return this.perms.playerHas(world, Bukkit.getOfflinePlayer(player), perm);
     }
 
     @Override
-    public boolean hasPermission(String player, String perm) {
-        return perms.playerHas((String) null, Bukkit.getOfflinePlayer(player), perm);
+    public double getBalance(PlotPlayer player) {
+        return this.econ.getBalance(player.getName());
     }
 }

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

@@ -1,16 +1,9 @@
 package com.plotsquared.bukkit.util;
 
-import java.util.ArrayList;
-import java.util.UUID;
-
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
-
 import com.intellectualcrafters.plot.flag.Flag;
 import com.intellectualcrafters.plot.object.Location;
 import com.intellectualcrafters.plot.object.Plot;
+import com.intellectualcrafters.plot.object.PlotArea;
 import com.intellectualcrafters.plot.object.PlotCluster;
 import com.intellectualcrafters.plot.object.PlotId;
 import com.intellectualcrafters.plot.object.PlotPlayer;
@@ -32,6 +25,13 @@ import com.plotsquared.bukkit.events.PlotMergeEvent;
 import com.plotsquared.bukkit.events.PlotRateEvent;
 import com.plotsquared.bukkit.events.PlotUnlinkEvent;
 import com.plotsquared.bukkit.object.BukkitPlayer;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+
+import java.util.ArrayList;
+import java.util.UUID;
 
 public class BukkitEventUtil extends EventUtil {
 
@@ -41,15 +41,12 @@ public class BukkitEventUtil extends EventUtil {
         }
         return null;
     }
-    
+
     public boolean callEvent(Event event) {
         Bukkit.getServer().getPluginManager().callEvent(event);
-        if (event instanceof Cancellable) {
-            return !((Cancellable) event).isCancelled();
-        }
-        return true;
+        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));
@@ -61,13 +58,13 @@ public class BukkitEventUtil extends EventUtil {
     }
 
     @Override
-    public boolean callClear(String world, PlotId id) {
-        return callEvent(new PlotClearEvent(world, id));
+    public boolean callClear(Plot plot) {
+        return callEvent(new PlotClearEvent(plot));
     }
 
     @Override
-    public void callDelete(String world, PlotId id) {
-        callEvent(new PlotDeleteEvent(world, id));
+    public void callDelete(Plot plot) {
+        callEvent(new PlotDeleteEvent(plot));
     }
 
     @Override
@@ -81,13 +78,13 @@ public class BukkitEventUtil extends EventUtil {
     }
 
     @Override
-    public boolean callMerge(String world, Plot plot, ArrayList<PlotId> plots) {
-        return callEvent(new PlotMergeEvent(BukkitUtil.getWorld(world), plot, plots));
+    public boolean callMerge(Plot plot, ArrayList<PlotId> plots) {
+        return callEvent(new PlotMergeEvent(BukkitUtil.getWorld(plot.getArea().worldname), plot, plots));
     }
 
     @Override
-    public boolean callUnlink(String world, ArrayList<PlotId> plots) {
-        return callEvent(new PlotUnlinkEvent(BukkitUtil.getWorld(world), plots));
+    public boolean callUnlink(PlotArea area, ArrayList<PlotId> plots) {
+        return callEvent(new PlotUnlinkEvent(BukkitUtil.getWorld(area.worldname), area, plots));
     }
 
     @Override
@@ -126,5 +123,5 @@ public class BukkitEventUtil extends EventUtil {
         Bukkit.getServer().getPluginManager().callEvent(event);
         return event.getRating();
     }
-    
+
 }

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

@@ -0,0 +1,322 @@
+package com.plotsquared.bukkit.util;
+
+import com.intellectualcrafters.plot.generator.HybridUtils;
+import com.intellectualcrafters.plot.object.Location;
+import com.intellectualcrafters.plot.object.PlotAnalysis;
+import com.intellectualcrafters.plot.object.PlotBlock;
+import com.intellectualcrafters.plot.object.RegionWrapper;
+import com.intellectualcrafters.plot.object.RunnableVal;
+import com.intellectualcrafters.plot.util.ChunkManager;
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.MathMan;
+import com.intellectualcrafters.plot.util.TaskManager;
+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.generator.ChunkGenerator;
+import org.bukkit.generator.ChunkGenerator.BiomeGrid;
+import org.bukkit.material.Directional;
+import org.bukkit.material.MaterialData;
+
+import java.util.HashSet;
+import java.util.Random;
+
+public class BukkitHybridUtils extends HybridUtils {
+
+    @Override
+    public void analyzeRegion(final String world, final RegionWrapper region, final RunnableVal<PlotAnalysis> whenDone) {
+        // int diff, int variety, int vertices, int rotation, int height_sd
+        /*
+         * diff: compare to base by looping through all blocks
+         * variety: add to HashSet for each PlotBlock
+         * height_sd: loop over all blocks and get top block
+         *
+         * vertices: store air map and compare with neighbours
+         * for each block check the adjacent
+         *  - Store all blocks then go through in second loop
+         *  - recheck each block
+         *
+         */
+        TaskManager.runTaskAsync(new Runnable() {
+            @Override
+            public void run() {
+                final World worldObj = Bukkit.getWorld(world);
+                final ChunkGenerator gen = worldObj.getGenerator();
+                if (gen == null) {
+                    return;
+                }
+                final BiomeGrid nullBiomeGrid = new BiomeGrid() {
+                    @Override
+                    public void setBiome(int a, int b, Biome c) {
+                    }
+
+                    @Override
+                    public Biome getBiome(int a, int b) {
+                        return null;
+                    }
+                };
+
+                final Location bot = new Location(world, region.minX, region.minY, region.minZ);
+                final Location top = new Location(world, region.maxX, region.maxY, region.maxZ);
+
+                final int bx = bot.getX();
+                final int bz = bot.getZ();
+                final int tx = top.getX();
+                final int tz = top.getZ();
+                final int cbx = bx >> 4;
+                final int cbz = bz >> 4;
+                final int ctx = tx >> 4;
+                final int ctz = tz >> 4;
+                final Random r = new Random();
+                MainUtil.initCache();
+                final int width = tx - bx + 1;
+                final int length = tz - bz + 1;
+
+                System.gc();
+                System.gc();
+                final short[][][] oldBlocks = new short[256][width][length];
+                final short[][][] newBlocks = new short[256][width][length];
+
+                final Runnable run = new Runnable() {
+                    @Override
+                    public void run() {
+                        ChunkManager.chunkTask(bot, top, new RunnableVal<int[]>() {
+                            @Override
+                            public void run(int[] value) {
+                                // [chunkx, chunkz, pos1x, pos1z, pos2x, pos2z, isedge]
+                                int X = value[0];
+                                int Z = value[1];
+                                short[][] result = gen.generateExtBlockSections(worldObj, r, X, Z, nullBiomeGrid);
+                                int xb = (X << 4) - bx;
+                                int zb = (Z << 4) - bz;
+                                for (int i = 0; i < result.length; i++) {
+                                    if (result[i] == null) {
+                                        for (int j = 0; j < 4096; j++) {
+                                            int x = MainUtil.x_loc[i][j] + xb;
+                                            if (x < 0 || x >= width) {
+                                                continue;
+                                            }
+                                            int z = MainUtil.z_loc[i][j] + zb;
+                                            if (z < 0 || z >= length) {
+                                                continue;
+                                            }
+                                            int y = MainUtil.y_loc[i][j];
+                                            oldBlocks[y][x][z] = 0;
+                                        }
+                                        continue;
+                                    }
+                                    for (int j = 0; j < result[i].length; j++) {
+                                        int x = MainUtil.x_loc[i][j] + xb;
+                                        if (x < 0 || x >= width) {
+                                            continue;
+                                        }
+                                        int z = MainUtil.z_loc[i][j] + zb;
+                                        if (z < 0 || z >= length) {
+                                            continue;
+                                        }
+                                        int y = MainUtil.y_loc[i][j];
+                                        oldBlocks[y][x][z] = result[i][j];
+                                    }
+                                }
+
+                            }
+                        }, new Runnable() {
+                            @Override
+                            public void run() {
+                                TaskManager.runTaskAsync(new Runnable() {
+                                    @Override
+                                    public void run() {
+                                        int size = width * length;
+                                        int[] changes = new int[size];
+                                        int[] faces = new int[size];
+                                        int[] data = new int[size];
+                                        int[] air = new int[size];
+                                        int[] variety = new int[size];
+                                        int i = 0;
+                                        for (int x = 0; x < width; x++) {
+                                            for (int z = 0; z < length; z++) {
+                                                HashSet<Short> types = new HashSet<>();
+                                                for (int y = 0; y < 256; y++) {
+                                                    short old = oldBlocks[y][x][z];
+                                                    short now = newBlocks[y][x][z];
+                                                    if (old != now) {
+                                                        changes[i]++;
+                                                    }
+                                                    if (now == 0) {
+                                                        air[i]++;
+                                                    } else {
+                                                        // check vertices
+                                                        // modifications_adjacent
+                                                        if (x > 0 && z > 0 && y > 0 && x < width - 1 && z < length - 1 && y < 255) {
+                                                            if (newBlocks[y - 1][x][z] == 0) {
+                                                                faces[i]++;
+                                                            }
+                                                            if (newBlocks[y][x - 1][z] == 0) {
+                                                                faces[i]++;
+                                                            }
+                                                            if (newBlocks[y][x][z - 1] == 0) {
+                                                                faces[i]++;
+                                                            }
+                                                            if (newBlocks[y + 1][x][z] == 0) {
+                                                                faces[i]++;
+                                                            }
+                                                            if (newBlocks[y][x + 1][z] == 0) {
+                                                                faces[i]++;
+                                                            }
+                                                            if (newBlocks[y][x][z + 1] == 0) {
+                                                                faces[i]++;
+                                                            }
+                                                        }
+
+                                                        Material material = Material.getMaterial(now);
+                                                        Class<? extends MaterialData> md = material.getData();
+                                                        if (md.equals(Directional.class)) {
+                                                            data[i] += 8;
+                                                        } else if (!md.equals(MaterialData.class)) {
+                                                            data[i]++;
+                                                        }
+                                                        types.add(now);
+                                                    }
+                                                }
+                                                variety[i] = types.size();
+                                                i++;
+                                            }
+                                        }
+                                        // analyze plot
+                                        // put in analysis obj
+
+                                        // run whenDone
+                                        PlotAnalysis analysis = new PlotAnalysis();
+                                        analysis.changes = (int) (MathMan.getMean(changes) * 100);
+                                        analysis.faces = (int) (MathMan.getMean(faces) * 100);
+                                        analysis.data = (int) (MathMan.getMean(data) * 100);
+                                        analysis.air = (int) (MathMan.getMean(air) * 100);
+                                        analysis.variety = (int) (MathMan.getMean(variety) * 100);
+
+                                        analysis.changes_sd = (int) MathMan.getSD(changes, analysis.changes);
+                                        analysis.faces_sd = (int) MathMan.getSD(faces, analysis.faces);
+                                        analysis.data_sd = (int) MathMan.getSD(data, analysis.data);
+                                        analysis.air_sd = (int) MathMan.getSD(air, analysis.air);
+                                        analysis.variety_sd = (int) MathMan.getSD(variety, analysis.variety);
+                                        System.gc();
+                                        System.gc();
+                                        whenDone.value = analysis;
+                                        whenDone.run();
+                                    }
+                                });
+                            }
+                        }, 5);
+
+                    }
+                };
+                System.gc();
+                MainUtil.initCache();
+                ChunkManager.chunkTask(bot, top, new RunnableVal<int[]>() {
+
+                    @Override
+                    public void run(int[] value) {
+                        int X = value[0];
+                        int Z = value[1];
+                        worldObj.loadChunk(X, Z);
+                        int minX;
+                        if (X == cbx) {
+                            minX = bx & 15;
+                        } else {
+                            minX = 0;
+                        }
+                        int minZ;
+                        if (Z == cbz) {
+                            minZ = bz & 15;
+                        } else {
+                            minZ = 0;
+                        }
+                        int maxX;
+                        if (X == ctx) {
+                            maxX = tx & 15;
+                        } else {
+                            maxX = 16;
+                        }
+                        int maxZ;
+                        if (Z == ctz) {
+                            maxZ = tz & 15;
+                        } else {
+                            maxZ = 16;
+                        }
+
+                        int cbx = X << 4;
+                        int cbz = Z << 4;
+
+                        int xb = cbx - bx;
+                        int zb = cbz - bz;
+                        for (int x = minX; x <= maxX; x++) {
+                            int xx = cbx + x;
+                            for (int z = minZ; z <= maxZ; z++) {
+                                int zz = cbz + z;
+                                for (int y = 0; y < 256; y++) {
+                                    Block block = worldObj.getBlockAt(xx, y, zz);
+                                    int xr = xb + x;
+                                    int zr = zb + z;
+                                    newBlocks[y][xr][zr] = (short) block.getTypeId();
+                                }
+                            }
+                        }
+                        worldObj.unloadChunkRequest(X, Z, true);
+                    }
+                }, new Runnable() {
+                    @Override
+                    public void run() {
+                        TaskManager.runTaskAsync(run);
+                    }
+                }, 5);
+            }
+        });
+    }
+
+    @Override
+    public int checkModified(String worldName, int x1, int x2, int y1, int y2, int z1, int z2,
+            PlotBlock[] blocks) {
+        World world = BukkitUtil.getWorld(worldName);
+        int count = 0;
+        for (int y = y1; y <= y2; y++) {
+            for (int x = x1; x <= x2; x++) {
+                for (int z = z1; z <= z2; z++) {
+                    Block block = world.getBlockAt(x, y, z);
+                    int id = block.getTypeId();
+                    boolean same = false;
+                    for (PlotBlock p : blocks) {
+                        if (id == p.id) {
+                            same = true;
+                            break;
+                        }
+                    }
+                    if (!same) {
+                        count++;
+                    }
+                }
+            }
+        }
+        return count;
+    }
+
+    @Override
+    public int get_ey(String worldName, int sx, int ex, int sz, int ez, int sy) {
+        World world = BukkitUtil.getWorld(worldName);
+        int maxY = world.getMaxHeight();
+        int ey = sy;
+        for (int x = sx; x <= ex; x++) {
+            for (int z = sz; z <= ez; z++) {
+                for (int y = sy; y < maxY; y++) {
+                    if (y > ey) {
+                        Block block = world.getBlockAt(x, y, z);
+                        if (!block.getType().equals(Material.AIR)) {
+                            ey = y;
+                        }
+                    }
+                }
+            }
+        }
+        return ey;
+    }
+}

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

@@ -1,8 +1,10 @@
 package com.plotsquared.bukkit.util;
 
-import java.util.ArrayList;
-import java.util.List;
-
+import com.intellectualcrafters.plot.object.PlotInventory;
+import com.intellectualcrafters.plot.object.PlotItemStack;
+import com.intellectualcrafters.plot.object.PlotPlayer;
+import com.intellectualcrafters.plot.util.InventoryUtil;
+import com.plotsquared.bukkit.object.BukkitPlayer;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.event.inventory.InventoryType;
@@ -12,72 +14,11 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.PlayerInventory;
 import org.bukkit.inventory.meta.ItemMeta;
 
-import com.intellectualcrafters.plot.object.PlotInventory;
-import com.intellectualcrafters.plot.object.PlotItemStack;
-import com.intellectualcrafters.plot.object.PlotPlayer;
-import com.intellectualcrafters.plot.util.InventoryUtil;
-import com.plotsquared.bukkit.object.BukkitPlayer;
+import java.util.ArrayList;
+import java.util.List;
 
 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));
-            }
-        }
-        inv.player.setMeta("inventory", inv);
-        bp.player.openInventory(inventory);
-    }
-
-    @Override
-    public void close(PlotInventory inv) {
-        if (!inv.isOpen()) {
-            return;
-        }
-        inv.player.deleteMeta("inventory");
-        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();
-    }
-    
-    public PlotItemStack getItem(ItemStack item ) {
-        if (item == null) {
-            return null;
-        }
-        int id = item.getTypeId();
-        short data = item.getDurability();
-        int amount = item.getAmount();
-        String name = null;
-        String[] lore = null;
-        if (item.hasItemMeta()) {
-            ItemMeta meta = item.getItemMeta();
-            if (meta.hasDisplayName()) {
-                name = meta.getDisplayName();
-            }
-            if (meta.hasLore()) {
-                List<String> itemLore = meta.getLore();
-                lore = itemLore.toArray(new String[itemLore.size()]);
-            }
-        }
-        return new PlotItemStack(id, data, amount, name, lore);
-    }
-    
     public static ItemStack getItem(PlotItemStack item) {
         if (item == null) {
             return null;
@@ -104,9 +45,67 @@ public class BukkitInventoryUtil extends InventoryUtil {
         return stack;
     }
 
+    @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));
+            }
+        }
+        inv.player.setMeta("inventory", inv);
+        bp.player.openInventory(inventory);
+    }
+
+    @Override
+    public void close(PlotInventory inv) {
+        if (!inv.isOpen()) {
+            return;
+        }
+        inv.player.deleteMeta("inventory");
+        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();
+    }
+
+    public PlotItemStack getItem(ItemStack item) {
+        if (item == null) {
+            return null;
+        }
+        int id = item.getTypeId();
+        short data = item.getDurability();
+        int amount = item.getAmount();
+        String name = null;
+        String[] lore = null;
+        if (item.hasItemMeta()) {
+            ItemMeta meta = item.getItemMeta();
+            if (meta.hasDisplayName()) {
+                name = meta.getDisplayName();
+            }
+            if (meta.hasLore()) {
+                List<String> itemLore = meta.getLore();
+                lore = itemLore.toArray(new String[itemLore.size()]);
+            }
+        }
+        return new PlotItemStack(id, data, amount, name, lore);
+    }
+
     @Override
     public PlotItemStack[] getItems(PlotPlayer player) {
-        BukkitPlayer bp = ((BukkitPlayer) player);
+        BukkitPlayer bp = (BukkitPlayer) player;
         PlayerInventory inv = bp.player.getInventory();
         PlotItemStack[] items = new PlotItemStack[36];
         for (int i = 0; i < 36; i++) {
@@ -120,8 +119,8 @@ public class BukkitInventoryUtil extends InventoryUtil {
         if (!inv.isOpen()) {
             return false;
         }
-        BukkitPlayer bp = ((BukkitPlayer) inv.player);
+        BukkitPlayer bp = (BukkitPlayer) inv.player;
         InventoryView opened = bp.player.getOpenInventory();
-        return (inv.isOpen() && opened.getType() == InventoryType.CRAFTING && opened.getTitle() == null);
+        return inv.isOpen() && opened.getType() == InventoryType.CRAFTING && opened.getTitle() == null;
     }
 }

Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitPlainChatManager.java

@@ -0,0 +1,50 @@
+package com.plotsquared.bukkit.util;
+
+import com.intellectualcrafters.plot.object.PlotMessage;
+import com.intellectualcrafters.plot.object.PlotPlayer;
+import com.intellectualcrafters.plot.util.ChatManager;
+import org.bukkit.ChatColor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BukkitPlainChatManager extends ChatManager<List<StringBuilder>> {
+
+    @Override
+    public List<StringBuilder> builder() {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public void color(PlotMessage m, String color) {
+        List<StringBuilder> parts = m.$(this);
+        parts.get(parts.size() - 1).insert(0, color);
+    }
+
+    @Override
+    public void tooltip(PlotMessage m, PlotMessage... tooltips) {
+    }
+
+    @Override
+    public void command(PlotMessage m, String command) {
+    }
+
+    @Override
+    public void text(PlotMessage m, String text) {
+        m.$(this).add(new StringBuilder(ChatColor.stripColor(text)));
+    }
+
+    @Override
+    public void send(PlotMessage m, PlotPlayer player) {
+        StringBuilder built = new StringBuilder();
+        for (StringBuilder sb : m.$(this)) {
+            built.append(sb);
+        }
+        player.sendMessage(built.toString());
+    }
+
+    @Override
+    public void suggest(PlotMessage m, String command) {
+    }
+
+}

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

@@ -0,0 +1,309 @@
+package com.plotsquared.bukkit.util;
+
+import com.intellectualcrafters.jnbt.ByteArrayTag;
+import com.intellectualcrafters.jnbt.CompoundTag;
+import com.intellectualcrafters.jnbt.IntTag;
+import com.intellectualcrafters.jnbt.ListTag;
+import com.intellectualcrafters.jnbt.ShortTag;
+import com.intellectualcrafters.jnbt.StringTag;
+import com.intellectualcrafters.jnbt.Tag;
+import com.intellectualcrafters.plot.object.ChunkLoc;
+import com.intellectualcrafters.plot.object.Location;
+import com.intellectualcrafters.plot.object.RegionWrapper;
+import com.intellectualcrafters.plot.object.RunnableVal;
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.SchematicHandler;
+import com.intellectualcrafters.plot.util.TaskManager;
+import com.plotsquared.bukkit.object.schematic.StateWrapper;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Schematic Handler.
+ */
+public class BukkitSchematicHandler extends SchematicHandler {
+
+    @Override
+    public void getCompoundTag(final String world, final Set<RegionWrapper> 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];
+                Location top = corners[1];
+
+                final int width = top.getX() - bot.getX() + 1;
+                int height = top.getY() - bot.getY() + 1;
+                final int length = top.getZ() - bot.getZ() + 1;
+                // Main Schematic tag
+                final HashMap<String, Tag> schematic = new HashMap<>();
+                schematic.put("Width", new ShortTag("Width", (short) width));
+                schematic.put("Length", new ShortTag("Length", (short) length));
+                schematic.put("Height", new ShortTag("Height", (short) height));
+                schematic.put("Materials", new StringTag("Materials", "Alpha"));
+                schematic.put("WEOriginX", new IntTag("WEOriginX", 0));
+                schematic.put("WEOriginY", new IntTag("WEOriginY", 0));
+                schematic.put("WEOriginZ", new IntTag("WEOriginZ", 0));
+                schematic.put("WEOffsetX", new IntTag("WEOffsetX", 0));
+                schematic.put("WEOffsetY", new IntTag("WEOffsetY", 0));
+                schematic.put("WEOffsetZ", new IntTag("WEOffsetZ", 0));
+                // Arrays of data types
+                final List<CompoundTag> tileEntities = new ArrayList<>();
+                final byte[] blocks = new byte[width * height * length];
+                final byte[] blockData = new byte[width * height * length];
+                // Queue
+                final ArrayDeque<RegionWrapper> queue = new ArrayDeque<>(regions);
+                TaskManager.runTask(new Runnable() {
+                    @Override
+                    public void run() {
+                        if (queue.isEmpty()) {
+                            TaskManager.runTaskAsync(new Runnable() {
+                                @Override
+                                public void run() {
+                                    schematic.put("Blocks", new ByteArrayTag("Blocks", blocks));
+                                    schematic.put("Data", new ByteArrayTag("Data", blockData));
+                                    schematic.put("Entities", new ListTag("Entities", CompoundTag.class, new ArrayList<Tag>()));
+                                    schematic.put("TileEntities", new ListTag("TileEntities", CompoundTag.class, tileEntities));
+                                    whenDone.value = new CompoundTag("Schematic", schematic);
+                                    TaskManager.runTask(whenDone);
+                                    System.gc();
+                                    System.gc();
+                                }
+                            });
+                            return;
+                        }
+                        final Runnable regionTask = this;
+                        RegionWrapper region = queue.poll();
+                        Location pos1 = new Location(world, region.minX, region.minY, region.minZ);
+                        Location pos2 = new Location(world, region.maxX, region.maxY, region.maxZ);
+                        final int bx = bot.getX();
+                        final int bz = bot.getZ();
+                        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 int sy = pos1.getY();
+                        final int ey = pos2.getY();
+                        // Generate list of chunks
+                        final ArrayList<ChunkLoc> chunks = new ArrayList<>();
+                        for (int x = bcx; x <= tcx; x++) {
+                            for (int z = bcz; z <= tcz; z++) {
+                                chunks.add(new ChunkLoc(x, z));
+                            }
+                        }
+                        final World worldObj = Bukkit.getWorld(world);
+                        // Main thread
+                        TaskManager.runTask(new Runnable() {
+                            @Override
+                            public void run() {
+                                long start = System.currentTimeMillis();
+                                while (!chunks.isEmpty() && System.currentTimeMillis() - start < 20) {
+                                    // save schematics
+                                    ChunkLoc chunk = chunks.remove(0);
+                                    Chunk bc = worldObj.getChunkAt(chunk.x, chunk.z);
+                                    if (!bc.load(false)) {
+                                        continue;
+                                    }
+                                    int X = chunk.x;
+                                    int Z = chunk.z;
+                                    int xxb = X << 4;
+                                    int zzb = Z << 4;
+                                    int xxt = xxb + 15;
+                                    int zzt = zzb + 15;
+
+                                    if (X == bcx) {
+                                        xxb = p1x;
+                                    }
+                                    if (X == tcx) {
+                                        xxt = p2x;
+                                    }
+                                    if (Z == bcz) {
+                                        zzb = p1z;
+                                    }
+                                    if (Z == tcz) {
+                                        zzt = p2z;
+                                    }
+                                    for (int y = sy; y <= Math.min(255, ey); y++) {
+                                        int ry = y - sy;
+                                        int i1 = ry * width * length;
+                                        for (int z = zzb; z <= zzt; z++) {
+                                            int rz = z - bz;
+                                            int i2 = i1 + rz * width;
+                                            for (int x = xxb; x <= xxt; x++) {
+                                                int rx = x - bx;
+                                                int index = i2 + rx;
+                                                Block block = worldObj.getBlockAt(x, y, z);
+                                                int id = block.getTypeId();
+                                                switch (id) {
+                                                    case 0:
+                                                    case 2:
+                                                    case 4:
+                                                    case 13:
+                                                    case 14:
+                                                    case 15:
+                                                    case 20:
+                                                    case 21:
+                                                    case 22:
+                                                    case 24:
+                                                    case 30:
+                                                    case 32:
+                                                    case 37:
+                                                    case 39:
+                                                    case 40:
+                                                    case 41:
+                                                    case 42:
+                                                    case 45:
+                                                    case 46:
+                                                    case 47:
+                                                    case 48:
+                                                    case 49:
+                                                    case 51:
+                                                    case 55:
+                                                    case 56:
+                                                    case 57:
+                                                    case 58:
+                                                    case 60:
+                                                    case 7:
+                                                    case 8:
+                                                    case 9:
+                                                    case 10:
+                                                    case 11:
+                                                    case 73:
+                                                    case 74:
+                                                    case 78:
+                                                    case 79:
+                                                    case 80:
+                                                    case 81:
+                                                    case 82:
+                                                    case 83:
+                                                    case 85:
+                                                    case 87:
+                                                    case 88:
+                                                    case 101:
+                                                    case 102:
+                                                    case 103:
+                                                    case 110:
+                                                    case 112:
+                                                    case 113:
+                                                    case 121:
+                                                    case 122:
+                                                    case 129:
+                                                    case 133:
+                                                    case 165:
+                                                    case 166:
+                                                    case 169:
+                                                    case 170:
+                                                    case 172:
+                                                    case 173:
+                                                    case 174:
+                                                    case 181:
+                                                    case 182:
+                                                    case 188:
+                                                    case 189:
+                                                    case 190:
+                                                    case 191:
+                                                    case 192:
+                                                        break;
+                                                    case 54:
+                                                    case 130:
+                                                    case 142:
+                                                    case 27:
+                                                    case 137:
+                                                    case 52:
+                                                    case 154:
+                                                    case 84:
+                                                    case 25:
+                                                    case 144:
+                                                    case 138:
+                                                    case 176:
+                                                    case 177:
+                                                    case 63:
+                                                    case 68:
+                                                    case 323:
+                                                    case 117:
+                                                    case 116:
+                                                    case 28:
+                                                    case 66:
+                                                    case 157:
+                                                    case 61:
+                                                    case 62:
+                                                    case 140:
+                                                    case 146:
+                                                    case 149:
+                                                    case 150:
+                                                    case 158:
+                                                    case 23:
+                                                    case 123:
+                                                    case 124:
+                                                    case 29:
+                                                    case 33:
+                                                    case 151:
+                                                    case 178:
+                                                        // TODO implement fully
+                                                        BlockState state = block.getState();
+                                                        if (state != null) {
+                                                            StateWrapper wrapper = new StateWrapper(state);
+                                                            CompoundTag rawTag = wrapper.getTag();
+                                                            if (rawTag != null) {
+                                                                Map<String, Tag> values = new HashMap<>(rawTag.getValue());
+                                                                values.put("id", new StringTag("id", wrapper.getId()));
+                                                                values.put("x", new IntTag("x", x));
+                                                                values.put("y", new IntTag("y", y));
+                                                                values.put("z", new IntTag("z", z));
+                                                                CompoundTag tileEntityTag = new CompoundTag(values);
+                                                                tileEntities.add(tileEntityTag);
+                                                            }
+                                                        }
+                                                    default:
+                                                        blockData[index] = block.getData();
+                                                }
+                                                // For optimization reasons, we are not supporting custom data types
+                                                // Especially since the most likely reason beyond  this range is modded servers in which the blocks
+                                                // have NBT
+                                                //                                        if (type > 255) {
+                                                //                                            if (addBlocks == null) {
+                                                //                                                addBlocks = new byte[(blocks.length >> 1) + 1];
+                                                //                                            }
+                                                //                                            addBlocks[index >> 1] = (byte) (((index & 1) == 0) ?
+                                                // (addBlocks[index >> 1] & 0xF0) | ((type >> 8) & 0xF) : (addBlocks[index >> 1] & 0xF) | (((type
+                                                // >> 8) & 0xF) << 4));
+                                                //                                        }
+                                                blocks[index] = (byte) id;
+                                            }
+                                        }
+                                    }
+                                }
+                                if (!chunks.isEmpty()) {
+                                    TaskManager.runTaskLater(this, 1);
+                                } else {
+                                    regionTask.run();
+                                }
+                            }
+                        });
+                    }
+                });
+            }
+        });
+    }
+
+    @Override
+    public void restoreTile(String world, CompoundTag ct, int x, int y, int z) {
+        new StateWrapper(ct).restoreTag(world, x, y, z);
+    }
+}

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

@@ -0,0 +1,202 @@
+package com.plotsquared.bukkit.util;
+
+import com.intellectualcrafters.configuration.ConfigurationSection;
+import com.intellectualcrafters.configuration.file.YamlConfiguration;
+import com.intellectualcrafters.plot.PS;
+import com.intellectualcrafters.plot.config.ConfigurationNode;
+import com.intellectualcrafters.plot.generator.GeneratorWrapper;
+import com.intellectualcrafters.plot.object.PlotArea;
+import com.intellectualcrafters.plot.object.SetupObject;
+import com.intellectualcrafters.plot.util.SetupUtils;
+import com.plotsquared.bukkit.generator.BukkitPlotGenerator;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.World.Environment;
+import org.bukkit.WorldCreator;
+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()) {
+            if (plugin.isEnabled()) {
+                ChunkGenerator generator = plugin.getDefaultWorldGenerator(testWorld, "");
+                if (generator != null) {
+                    PS.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);
+                }
+            }
+        }
+    }
+
+    @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;
+        if (!PS.get().config.contains(worldPath)) {
+            PS.get().config.createSection(worldPath);
+        }
+        ConfigurationSection worldSection = PS.get().config.getConfigurationSection(worldPath);
+        switch (type) {
+            case 2: {
+                if (object.id != null) {
+                    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:
+                for (ConfigurationNode step : steps) {
+                    worldSection.set(step.getConstant(), step.getValue());
+                }
+                PS.get().config.set("worlds." + world + "." + "generator.type", object.type);
+                PS.get().config.set("worlds." + world + "." + "generator.terrain", object.terrain);
+                PS.get().config.set("worlds." + world + "." + "generator.plugin", object.plotManager);
+                if (object.setupGenerator != null && !object.setupGenerator.equals(object.plotManager)) {
+                    PS.get().config.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:
+                for (ConfigurationNode step : steps) {
+                    worldSection.set(step.getConstant(), step.getValue());
+                }
+                break;
+        }
+        try {
+            PS.get().config.save(PS.get().configFile);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        if (object.setupGenerator != null) {
+            if (Bukkit.getPluginManager().getPlugin("Multiverse-Core") != null && Bukkit.getPluginManager().getPlugin("Multiverse-Core")
+                    .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;
+                }
+            }
+            if (Bukkit.getPluginManager().getPlugin("MultiWorld") != null && Bukkit.getPluginManager().getPlugin("MultiWorld").isEnabled()) {
+                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), "mw create " + world + " plugin:" + 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);
+            Bukkit.createWorld(wc);
+            setGenerator(world, object.setupGenerator);
+        } else {
+            if (Bukkit.getPluginManager().getPlugin("Multiverse-Core") != null && Bukkit.getPluginManager().getPlugin("Multiverse-Core")
+                    .isEnabled()) {
+                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), "mv create " + world + " normal");
+                if (Bukkit.getWorld(world) != null) {
+                    return world;
+                }
+            }
+            if (Bukkit.getPluginManager().getPlugin("MultiWorld") != null && Bukkit.getPluginManager().getPlugin("MultiWorld").isEnabled()) {
+                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), "mw create " + world);
+                if (Bukkit.getWorld(world) != null) {
+                    return world;
+                }
+            }
+            Bukkit.createWorld(new WorldCreator(object.world).environment(World.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 plotworld) {
+        if (SetupUtils.generators.isEmpty()) {
+            updateGenerators();
+        }
+        World world = Bukkit.getWorld(plotworld.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/plotsquared/bukkit/util/BukkitTaskManager.java

@@ -1,43 +1,44 @@
 package com.plotsquared.bukkit.util;
 
-import org.bukkit.Bukkit;
-
 import com.intellectualcrafters.plot.util.TaskManager;
 import com.plotsquared.bukkit.BukkitMain;
+import org.bukkit.Bukkit;
 
 public class BukkitTaskManager extends TaskManager {
+
     @Override
-    public int taskRepeat(final Runnable r, final int interval) {
-        return BukkitMain.THIS.getServer().getScheduler().scheduleSyncRepeatingTask(BukkitMain.THIS, r, interval, interval);
+    public int taskRepeat(Runnable runnable, int interval) {
+        return BukkitMain.THIS.getServer().getScheduler().scheduleSyncRepeatingTask(BukkitMain.THIS, runnable, interval, interval);
     }
-    
+
+    @SuppressWarnings("deprecation")
     @Override
-    public int taskRepeatAsync(final Runnable r, final int interval) {
-        return BukkitMain.THIS.getServer().getScheduler().scheduleAsyncRepeatingTask(BukkitMain.THIS, r, interval, interval);
+    public int taskRepeatAsync(Runnable runnable, int interval) {
+        return BukkitMain.THIS.getServer().getScheduler().scheduleAsyncRepeatingTask(BukkitMain.THIS, runnable, interval, interval);
     }
 
     @Override
-    public void taskAsync(final Runnable r) {
-        BukkitMain.THIS.getServer().getScheduler().runTaskAsynchronously(BukkitMain.THIS, r).getTaskId();
+    public void taskAsync(Runnable runnable) {
+        BukkitMain.THIS.getServer().getScheduler().runTaskAsynchronously(BukkitMain.THIS, runnable).getTaskId();
     }
 
     @Override
-    public void task(final Runnable r) {
-        BukkitMain.THIS.getServer().getScheduler().runTask(BukkitMain.THIS, r).getTaskId();
+    public void task(Runnable runnable) {
+        BukkitMain.THIS.getServer().getScheduler().runTask(BukkitMain.THIS, runnable).getTaskId();
     }
 
     @Override
-    public void taskLater(final Runnable r, final int delay) {
-        BukkitMain.THIS.getServer().getScheduler().runTaskLater(BukkitMain.THIS, r, delay).getTaskId();
+    public void taskLater(Runnable runnable, int delay) {
+        BukkitMain.THIS.getServer().getScheduler().runTaskLater(BukkitMain.THIS, runnable, delay).getTaskId();
     }
 
     @Override
-    public void taskLaterAsync(final Runnable r, final int delay) {
-        BukkitMain.THIS.getServer().getScheduler().runTaskLaterAsynchronously(BukkitMain.THIS, r, delay);
+    public void taskLaterAsync(Runnable runnable, int delay) {
+        BukkitMain.THIS.getServer().getScheduler().runTaskLaterAsynchronously(BukkitMain.THIS, runnable, delay);
     }
-    
+
     @Override
-    public void cancelTask(final int task) {
+    public void cancelTask(int task) {
         if (task != -1) {
             Bukkit.getScheduler().cancelTask(task);
         }

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

@@ -0,0 +1,330 @@
+package com.plotsquared.bukkit.util;
+
+import com.intellectualcrafters.plot.object.Location;
+import com.intellectualcrafters.plot.object.PlotBlock;
+import com.intellectualcrafters.plot.object.PlotPlayer;
+import com.intellectualcrafters.plot.object.RegionWrapper;
+import com.intellectualcrafters.plot.object.schematic.PlotItem;
+import com.intellectualcrafters.plot.util.MathMan;
+import com.intellectualcrafters.plot.util.StringComparison;
+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.plotsquared.bukkit.object.BukkitPlayer;
+import java.util.Arrays;
+import java.util.List;
+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.BlockState;
+import org.bukkit.block.Sign;
+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.bukkit.material.MaterialData;
+import org.bukkit.material.Sandstone;
+import org.bukkit.material.Step;
+import org.bukkit.material.Tree;
+import org.bukkit.material.WoodenStep;
+import org.bukkit.material.Wool;
+
+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 plr) {
+        lastPlayer = null;
+        lastPlotPlayer = null;
+    }
+
+    public static PlotPlayer getPlayer(OfflinePlayer op) {
+        if (op.isOnline()) {
+            return getPlayer(op.getPlayer());
+        }
+        Player player = OfflinePlayerUtil.loadPlayer(op);
+        player.loadData();
+        return new BukkitPlayer(player, true);
+    }
+
+    public static PlotPlayer getPlayer(Player player) {
+        if (player == lastPlayer) {
+            return lastPlotPlayer;
+        }
+        String name = player.getName();
+        PlotPlayer pp = UUIDHandler.getPlayer(name);
+        if (pp != null) {
+            return pp;
+        }
+        lastPlotPlayer = new BukkitPlayer(player);
+        UUIDHandler.getPlayers().put(name, lastPlotPlayer);
+        lastPlayer = player;
+        return lastPlotPlayer;
+    }
+
+    public static Location getLocation(org.bukkit.Location location) {
+        return new Location(location.getWorld().getName(), MathMan.roundInt(location.getX()), MathMan.roundInt(location.getY()),
+                MathMan.roundInt(location.getZ()));
+    }
+
+    public static org.bukkit.Location getLocation(Location location) {
+        return new org.bukkit.Location(getWorld(location.getWorld()), location.getX(), location.getY(), location.getZ());
+    }
+
+    public static World getWorld(String string) {
+        if (StringMan.isEqual(string, lastString)) {
+            if (lastWorld != null) {
+                return lastWorld;
+            }
+        }
+        World world = Bukkit.getWorld(string);
+        lastString = string;
+        lastWorld = world;
+        return world;
+    }
+
+    public static String getWorld(Entity entity) {
+        return entity.getWorld().getName();
+    }
+
+    public static List<Entity> getEntities(String worldName) {
+        return getWorld(worldName).getEntities();
+    }
+
+    public static Location getLocation(Entity entity) {
+        org.bukkit.Location loc = entity.getLocation();
+        String world = loc.getWorld().getName();
+        return new Location(world, loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
+    }
+
+    public static Location getLocationFull(Entity entity) {
+        org.bukkit.Location loc = entity.getLocation();
+        return new Location(loc.getWorld().getName(), MathMan.roundInt(loc.getX()), MathMan.roundInt(loc.getY()), MathMan.roundInt(loc.getZ()),
+                loc.getYaw(), loc.getPitch());
+    }
+
+    @Override
+    public boolean isWorld(String worldName) {
+        return getWorld(worldName) != null;
+    }
+
+    @Override
+    public String getBiome(String world, int x, int z) {
+        return getWorld(world).getBiome(x, z).name();
+    }
+
+    @Override
+    public void setSign(String worldName, int x, int y, int z, String[] lines) {
+        World world = getWorld(worldName);
+        Block block = world.getBlockAt(x, y, z);
+        //        block.setType(Material.AIR);
+        block.setTypeIdAndData(Material.WALL_SIGN.getId(), (byte) 2, false);
+        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);
+            TaskManager.runTaskLater(new Runnable() {
+                @Override
+                public void run() {
+                    sign.update(true);
+                }
+            }, 20);
+        }
+    }
+
+    @Override
+    public String[] getSign(Location location) {
+        Block block = getWorld(location.getWorld()).getBlockAt(location.getX(), location.getY(), location.getZ());
+        if (block != null) {
+            if (block.getState() instanceof Sign) {
+                Sign sign = (Sign) block.getState();
+                return sign.getLines();
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public Location getSpawn(PlotPlayer pp) {
+        return getLocation(((BukkitPlayer) pp).player.getBedSpawnLocation());
+    }
+
+    @Override
+    public Location getSpawn(String world) {
+        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(Location location) {
+        World world = getWorld(location.getWorld());
+        if (world != null) {
+            world.setSpawnLocation(location.getX(), location.getY(), location.getZ());
+        }
+    }
+
+    @Override
+    public void saveWorld(String worldName) {
+        World world = getWorld(worldName);
+        if (world != null) {
+            world.save();
+        }
+    }
+
+    @Override
+    public int getHighestBlock(String world, int x, int z) {
+        return getWorld(world).getHighestBlockAt(x, z).getY();
+    }
+
+    @Override
+    public int getBiomeFromString(String biomeStr) {
+        try {
+            Biome biome = Biome.valueOf(biomeStr.toUpperCase());
+            return Arrays.asList(Biome.values()).indexOf(biome);
+        } catch (IllegalArgumentException e) {
+            return -1;
+        }
+    }
+
+    @Override
+    public String[] getBiomeList() {
+        Biome[] biomes = Biome.values();
+        String[] list = new String[biomes.length];
+        for (int i = 0; i < biomes.length; i++) {
+            list[i] = biomes[i].name();
+        }
+        return list;
+    }
+
+    @Override
+    public boolean addItems(String worldName, PlotItem items) {
+        World world = getWorld(worldName);
+        Block block = world.getBlockAt(items.x, items.y, items.z);
+        if (block == null) {
+            return false;
+        }
+        BlockState state = block.getState();
+        if (state instanceof InventoryHolder) {
+            InventoryHolder holder = (InventoryHolder) state;
+            Inventory inv = holder.getInventory();
+            for (int i = 0; i < items.id.length; i++) {
+                ItemStack item = new ItemStack(items.id[i], items.amount[i], items.data[i]);
+                inv.addItem(item);
+            }
+            state.update(true);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isBlockSolid(PlotBlock block) {
+        try {
+            Material material = Material.getMaterial(block.id);
+            if (material.isBlock() && material.isSolid() && !material.hasGravity()) {
+                Class<? extends MaterialData> data = material.getData();
+                if (data.equals(MaterialData.class) && !material.isTransparent() && material.isOccluding()
+                        || data.equals(Tree.class)
+                        || data.equals(Sandstone.class)
+                        || data.equals(Wool.class)
+                        || data.equals(Step.class)
+                        || data.equals(WoodenStep.class)) {
+                    switch (material) {
+                        case NOTE_BLOCK:
+                        case MOB_SPAWNER:
+                            return false;
+                        default:
+                            return true;
+                    }
+                }
+            }
+            return false;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    @Override
+    public String getClosestMatchingName(PlotBlock block) {
+        try {
+            return Material.getMaterial(block.id).name();
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    @Override
+    public StringComparison<PlotBlock>.ComparisonResult getClosestBlock(String name) {
+        try {
+            Material material = Material.valueOf(name.toUpperCase());
+            return new StringComparison<PlotBlock>().new ComparisonResult(0, new PlotBlock((short) material.getId(), (byte) 0));
+        } catch (IllegalArgumentException e) {
+            //ignored
+        }
+        try {
+            byte data;
+            String[] split = name.split(":");
+            if (split.length == 2) {
+                data = Byte.parseByte(split[1]);
+                name = split[0];
+            } else {
+                data = 0;
+            }
+            double match;
+            short id;
+            if (MathMan.isInteger(split[0])) {
+                id = Short.parseShort(split[0]);
+                match = 0;
+            } else {
+                StringComparison<Material>.ComparisonResult comparison = new StringComparison<>(name, Material.values()).getBestMatchAdvanced();
+                match = comparison.match;
+                id = (short) comparison.best.getId();
+            }
+            PlotBlock block = new PlotBlock(id, data);
+            StringComparison<PlotBlock> outer = new StringComparison<>();
+            return outer.new ComparisonResult(match, block);
+
+        } catch (NumberFormatException e) {
+            //ignored
+        }
+        return null;
+    }
+
+    @Override
+    public void setBiomes(String worldName, RegionWrapper region, String biomeStr) {
+        World world = getWorld(worldName);
+        Biome biome = Biome.valueOf(biomeStr.toUpperCase());
+        for (int x = region.minX; x <= region.maxX; x++) {
+            for (int z = region.minZ; z <= region.maxZ; z++) {
+                world.setBiome(x, z, biome);
+            }
+        }
+    }
+
+    @Override
+    public PlotBlock getBlock(Location location) {
+        World world = getWorld(location.getWorld());
+        Block block = world.getBlockAt(location.getX(), location.getY(), location.getZ());
+        if (block == null) {
+            return PlotBlock.EVERYTHING;
+        }
+        return new PlotBlock((short) block.getTypeId(), block.getData());
+    }
+
+    @Override
+    public String getMainWorld() {
+        return Bukkit.getWorlds().get(0).getName();
+    }
+}

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

@@ -1,25 +1,12 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// 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.util;
 
+import com.intellectualcrafters.plot.PS;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.PluginDescriptionFile;
+import org.bukkit.scheduler.BukkitTask;
+
 import java.io.BufferedReader;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
@@ -41,108 +28,74 @@ import java.util.UUID;
 import java.util.logging.Level;
 import java.util.zip.GZIPOutputStream;
 
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.PluginDescriptionFile;
-import org.bukkit.scheduler.BukkitTask;
-
-import com.intellectualcrafters.configuration.InvalidConfigurationException;
-import com.intellectualcrafters.configuration.file.YamlConfiguration;
-import com.intellectualcrafters.plot.PS;
-
 public class Metrics {
+
     /**
-     * The current revision number
+     * The current revision number.
      */
-    private final static int REVISION = 7;
+    private static final int REVISION = 7;
     /**
-     * The base url of the metrics domain
+     * The base url of the metrics domain.
      */
     private static final String BASE_URL = "http://report.mcstats.org";
     /**
-     * The url used to report a server's status
+     * The url used to report a server's status.
      */
     private static final String REPORT_URL = "/plugin/%s";
     /**
-     * Interval of time to ping (in minutes)
+     * Interval of time to ping (in minutes).
      */
     private static final int PING_INTERVAL = 15;
     /**
-     * The plugin this metrics submits for
+     * The plugin this metrics submits for.
      */
     private final Plugin plugin;
     /**
-     * All of the custom graphs to submit to metrics
+     * All of the custom graphs to submit to metrics.
      */
     private final Set<Graph> graphs = Collections.synchronizedSet(new HashSet<Graph>());
     /**
-     * The plugin configuration file
-     */
-    private final YamlConfiguration configuration;
-    /**
-     * The plugin configuration file
-     */
-    private final File configurationFile;
-    /**
-     * Unique server id
+     * Unique server id.
      */
     private final String guid;
     /**
-     * Debug mode
+     * Debug mode.
      */
     private final boolean debug;
     /**
-     * Lock for synchronization
-     */
-    private final Object optOutLock = new Object();
-    /**
-     * The scheduled task
+     * The scheduled task.
      */
     private volatile BukkitTask task = null;
 
-    public Metrics(final Plugin plugin) throws IOException {
+    public Metrics(Plugin plugin) {
         if (plugin == null) {
             throw new IllegalArgumentException("Plugin cannot be null");
         }
         this.plugin = plugin;
-        // load the config
-        this.configurationFile = getConfigFile();
-        this.configuration = YamlConfiguration.loadConfiguration(this.configurationFile);
-        // add some defaults
-        this.configuration.addDefault("opt-out", false);
-        this.configuration.addDefault("guid", UUID.randomUUID().toString());
-        this.configuration.addDefault("debug", false);
-        // Do we need to create the file?
-        if (this.configuration.get("guid", null) == null) {
-            this.configuration.options().header("http://mcstats.org").copyDefaults(true);
-            this.configuration.save(this.configurationFile);
-        }
-        // Load the guid then
-        this.guid = this.configuration.getString("guid");
-        this.debug = this.configuration.getBoolean("debug", false);
+        this.guid = UUID.randomUUID().toString();
+        this.debug = false;
     }
 
     /**
-     * GZip compress a string of bytes
+     * GZip compress a string of bytes.
      *
      * @param input
      *
      * @return byte[] the file as a byte array
      */
-    public static byte[] gzip(final String input) {
-        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
+    public static byte[] gzip(String input) {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
         GZIPOutputStream gzos = null;
         try {
             gzos = new GZIPOutputStream(baos);
             gzos.write(input.getBytes("UTF-8"));
-        } catch (final IOException e) {
+        } catch (IOException e) {
             e.printStackTrace();
         } finally {
             if (gzos != null) {
                 try {
                     gzos.close();
-                } catch (final IOException ignore) {
+                } catch (IOException ignore) {
                 }
             }
         }
@@ -156,16 +109,15 @@ public class Metrics {
      * @param key
      * @param value
      *
-     * @throws UnsupportedEncodingException
      */
-    private static void appendJSONPair(final StringBuilder json, final String key, final String value) throws UnsupportedEncodingException {
+    private static void appendJSONPair(StringBuilder json, String key, String value) {
         boolean isValueNumeric = false;
         try {
             if (value.equals("0") || !value.endsWith("0")) {
                 Double.parseDouble(value);
                 isValueNumeric = true;
             }
-        } catch (final NumberFormatException e) {
+        } catch (NumberFormatException e) {
             isValueNumeric = false;
         }
         if (json.charAt(json.length() - 1) != '{') {
@@ -187,11 +139,11 @@ public class Metrics {
      *
      * @return String
      */
-    private static String escapeJSON(final String text) {
-        final StringBuilder builder = new StringBuilder();
+    private static String escapeJSON(String text) {
+        StringBuilder builder = new StringBuilder();
         builder.append('"');
         for (int index = 0; index < text.length(); index++) {
-            final char chr = text.charAt(index);
+            char chr = text.charAt(index);
             switch (chr) {
                 case '"':
                 case '\\':
@@ -212,7 +164,7 @@ public class Metrics {
                     break;
                 default:
                     if (chr < ' ') {
-                        final String t = "000" + Integer.toHexString(chr);
+                        String t = "000" + Integer.toHexString(chr);
                         builder.append("\\u" + t.substring(t.length() - 4));
                     } else {
                         builder.append(chr);
@@ -231,7 +183,7 @@ public class Metrics {
      *
      * @return the encoded text, as UTF-8
      */
-    private static String urlEncode(final String text) throws UnsupportedEncodingException {
+    private static String urlEncode(String text) throws UnsupportedEncodingException {
         return URLEncoder.encode(text, "UTF-8");
     }
 
@@ -243,12 +195,12 @@ public class Metrics {
      *
      * @return Graph object created. Will never return NULL under normal circumstances unless bad parameters are given
      */
-    public Graph createGraph(final String name) {
+    public Graph createGraph(String name) {
         if (name == null) {
             throw new IllegalArgumentException("Graph name cannot be null");
         }
         // Construct the graph object
-        final Graph graph = new Graph(name);
+        Graph graph = new Graph(name);
         // Now we can add our graph
         this.graphs.add(graph);
         // and return back
@@ -260,7 +212,7 @@ public class Metrics {
      *
      * @param graph The name of the graph
      */
-    public void addGraph(final Graph graph) {
+    public void addGraph(Graph graph) {
         if (graph == null) {
             throw new IllegalArgumentException("Graph cannot be null");
         }
@@ -275,86 +227,31 @@ public class Metrics {
      * @return True if statistics measuring is running, otherwise false.
      */
     public boolean start() {
-        synchronized (this.optOutLock) {
-            // Did we opt out?
-            if (isOptOut()) {
-                return false;
-            }
-            // Is metrics already running?
-            if (this.task != null) {
-                return true;
-            }
-            // Begin hitting the server with glorious data
-            this.task = this.plugin.getServer().getScheduler().runTaskTimerAsynchronously(this.plugin, new Runnable() {
-                private boolean firstPost = true;
-
-                @Override
-                public void run() {
-                    try {
-                        // This has to be synchronized or it can collide
-                        // with
-                        // the disable method.
-                        synchronized (Metrics.this.optOutLock) {
-                            // Disable Task, if it is running and the
-                            // server
-                            // owner decided to opt-out
-                            if (isOptOut() && (Metrics.this.task != null)) {
-                                Metrics.this.task.cancel();
-                                Metrics.this.task = null;
-                                // Tell all plotters to stop gathering
-                                // information.
-                                for (final Graph graph : Metrics.this.graphs) {
-                                    graph.onOptOut();
-                                }
-                            }
-                        }
-                        // We use the inverse of firstPost because if it
-                        // is the
-                        // first time we are posting,
-                        // it is not a interval ping, so it evaluates to
-                        // FALSE
-                        // Each time thereafter it will evaluate to
-                        // TRUE, i.e
-                        // PING!
-                        postPlugin(!this.firstPost);
-                        // After the first post we set firstPost to
-                        // false
-                        // Each post thereafter will be a ping
-                        this.firstPost = false;
-                    } catch (final IOException e) {
-                        if (Metrics.this.debug) {
-                            Bukkit.getLogger().log(Level.INFO, "[Metrics] " + e.getMessage());
-                        }
-                    }
-                }
-            }, 0, PING_INTERVAL * 1200);
+        // Is metrics already running?
+        if (this.task != null) {
             return true;
         }
-    }
+        // Begin hitting the server with glorious data
+        this.task = this.plugin.getServer().getScheduler().runTaskTimerAsynchronously(this.plugin, new Runnable() {
+            private boolean firstPost = true;
 
-    /**
-     * Has the server owner denied plugin metrics?
-     *
-     * @return true if metrics should be opted out of it
-     */
-    public boolean isOptOut() {
-        synchronized (this.optOutLock) {
-            try {
-                // Reload the metrics file
-                this.configuration.load(getConfigFile());
-            } catch (final IOException ex) {
-                if (this.debug) {
-                    Bukkit.getLogger().log(Level.INFO, "[Metrics] " + ex.getMessage());
+            @Override
+            public void run() {
+                try {
+                    postPlugin(!this.firstPost);
+                    // After the first post we set firstPost to
+                    // false
+                    // Each post thereafter will be a ping
+                    this.firstPost = false;
+                } catch (IOException e) {
+                    e.printStackTrace();
+                    if (Metrics.this.debug) {
+                        Bukkit.getLogger().log(Level.INFO, "[Metrics] " + e.getMessage());
+                    }
                 }
-                return true;
-            } catch (final InvalidConfigurationException ex) {
-                if (this.debug) {
-                    Bukkit.getLogger().log(Level.INFO, "[Metrics] " + ex.getMessage());
-                }
-                return true;
             }
-            return this.configuration.getBoolean("opt-out", false);
-        }
+        }, 0, PING_INTERVAL * 1200);
+        return true;
     }
 
     /**
@@ -362,48 +259,28 @@ public class Metrics {
      *
      * @throws java.io.IOException
      */
-    public void enable() throws IOException {
-        // This has to be synchronized or it can collide with the check in the
-        // task.
-        synchronized (this.optOutLock) {
-            // Check if the server owner has already set opt-out, if not, set
-            // it.
-            if (isOptOut()) {
-                this.configuration.set("opt-out", false);
-                this.configuration.save(this.configurationFile);
-            }
-            // Enable Task, if it is not running
-            if (this.task == null) {
-                start();
-            }
+    public void enable() {
+        // Enable Task, if it is not running
+        if (this.task == null) {
+            start();
         }
     }
 
     /**
      * Disables metrics for the server by setting "opt-out" to true in the config file and canceling the metrics task.
      *
-     * @throws java.io.IOException
      */
-    public void disable() throws IOException {
-        // This has to be synchronized or it can collide with the check in the
-        // task.
-        synchronized (this.optOutLock) {
-            // Check if the server owner has already set opt-out, if not, set
-            // it.
-            if (!isOptOut()) {
-                this.configuration.set("opt-out", true);
-                this.configuration.save(this.configurationFile);
-            }
-            // Disable Task, if it is running
-            if (this.task != null) {
-                this.task.cancel();
-                this.task = null;
-            }
+    public void disable() {
+        // Disable Task, if it is running
+        if (this.task != null) {
+            this.task.cancel();
+            this.task = null;
         }
     }
 
     /**
-     * Gets the File object of the config file that should be used to store data such as the GUID and opt-out status
+     * Gets the File object of the config file that should be used to store
+     * data such as the GUID and opt-out status.
      *
      * @return the File object for the config file
      */
@@ -414,52 +291,47 @@ public class Metrics {
         // plugin.getDataFolder() => base/plugins/PluginA/
         // pluginsFolder => base/plugins/
         // The base is not necessarily relative to the startup directory.
-        final File pluginsFolder = this.plugin.getDataFolder().getParentFile();
+        File pluginsFolder = this.plugin.getDataFolder().getParentFile();
         // return => base/plugins/PluginMetrics/config.yml
         return new File(new File(pluginsFolder, "PluginMetrics"), "config.yml");
     }
 
     /**
-     * Generic method that posts a plugin to the metrics website
+     * Generic method that posts a plugin to the metrics website.
      */
-    private void postPlugin(final boolean isPing) throws IOException {
+    private void postPlugin(boolean isPing) throws IOException {
         // Server software specific section
-        final PluginDescriptionFile description = this.plugin.getDescription();
-        final String pluginName = description.getName();
-        final boolean onlineMode = Bukkit.getServer().getOnlineMode(); // TRUE
-        // if
-        // online
-        // mode
-        // is
-        // enabled
-        final String pluginVersion = description.getVersion();
-        final String serverVersion = Bukkit.getVersion();
+        PluginDescriptionFile description = this.plugin.getDescription();
+        String pluginName = description.getName();
+        boolean onlineMode = Bukkit.getServer().getOnlineMode(); // TRUE if online mode is enabled
+        String pluginVersion = description.getVersion();
+        String serverVersion = Bukkit.getVersion();
         int playersOnline = 0;
         try {
             if (Bukkit.class.getMethod("getOnlinePlayers", new Class<?>[0]).getReturnType() == Collection.class) {
-                playersOnline = ((Collection<?>) Bukkit.class.getMethod("getOnlinePlayers", new Class<?>[0]).invoke(null, new Object[0])).size();
+                playersOnline = ((Collection<?>) Bukkit.class.getMethod("getOnlinePlayers", new Class<?>[0]).invoke(null)).size();
             } else {
-                playersOnline = ((Player[]) Bukkit.class.getMethod("getOnlinePlayers", new Class<?>[0]).invoke(null, new Object[0])).length;
+                playersOnline = ((Player[]) Bukkit.class.getMethod("getOnlinePlayers", new Class<?>[0]).invoke(null)).length;
             }
         } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException ex) {
+            ex.printStackTrace();
         }
         // END server software specific section -- all code below does not use
         // any code outside of this class / Java
         // Construct the post data
-        final StringBuilder json = new StringBuilder(1024);
+        StringBuilder json = new StringBuilder(1024);
         json.append('{');
-        // The plugin's description file containg all of the plugin data such as
-        // name, version, author, etc
+        // The plugin's description file containing all of the plugin data such as name, version, author, etc
         appendJSONPair(json, "guid", this.guid);
         appendJSONPair(json, "plugin_version", pluginVersion);
         appendJSONPair(json, "server_version", serverVersion);
         appendJSONPair(json, "players_online", Integer.toString(playersOnline));
         // New data as of R6
-        final String osname = System.getProperty("os.name");
+        String osname = System.getProperty("os.name");
         String osarch = System.getProperty("os.arch");
-        final String osversion = System.getProperty("os.version");
-        final String java_version = System.getProperty("java.version");
-        final int coreCount = Runtime.getRuntime().availableProcessors();
+        String osversion = System.getProperty("os.version");
+        String java_version = System.getProperty("java.version");
+        int coreCount = Runtime.getRuntime().availableProcessors();
         // normalize os arch .. amd64 -> x86_64
         if (osarch.equals("amd64")) {
             osarch = "x86_64";
@@ -474,7 +346,7 @@ public class Metrics {
         if (isPing) {
             appendJSONPair(json, "ping", "1");
         }
-        if (this.graphs.size() > 0) {
+        if (!this.graphs.isEmpty()) {
             synchronized (this.graphs) {
                 json.append(',');
                 json.append('"');
@@ -483,10 +355,10 @@ public class Metrics {
                 json.append(':');
                 json.append('{');
                 boolean firstGraph = true;
-                for (final Graph graph : this.graphs) {
-                    final StringBuilder graphJson = new StringBuilder();
+                for (Graph graph : this.graphs) {
+                    StringBuilder graphJson = new StringBuilder();
                     graphJson.append('{');
-                    for (final Plotter plotter : graph.getPlotters()) {
+                    for (Plotter plotter : graph.getPlotters()) {
                         appendJSONPair(graphJson, plotter.getColumnName(), Integer.toString(plotter.getValue()));
                     }
                     graphJson.append('}');
@@ -504,7 +376,7 @@ public class Metrics {
         // close json
         json.append('}');
         // Create the url
-        final URL url = new URL(BASE_URL + String.format(REPORT_URL, urlEncode(pluginName)));
+        URL url = new URL(BASE_URL + String.format(REPORT_URL, urlEncode(pluginName)));
         // Connect to the website
         URLConnection connection;
         // Mineshafter creates a socks proxy, so we can safely bypass it
@@ -514,8 +386,8 @@ public class Metrics {
         } else {
             connection = url.openConnection();
         }
-        final byte[] uncompressed = json.toString().getBytes();
-        final byte[] compressed = gzip(json.toString());
+        byte[] uncompressed = json.toString().getBytes();
+        byte[] compressed = gzip(json.toString());
         // Headers
         connection.addRequestProperty("User-Agent", "MCStats/" + REVISION);
         connection.addRequestProperty("Content-Type", "application/json");
@@ -527,34 +399,41 @@ public class Metrics {
         if (this.debug) {
             PS.debug("[Metrics] Prepared request for " + pluginName + " uncompressed=" + uncompressed.length + " compressed=" + compressed.length);
         }
-        // Write the data
-        final OutputStream os = connection.getOutputStream();
-        os.write(compressed);
-        os.flush();
-        // Now read the response
-        final BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
-        String response = reader.readLine();
-        // close resources
-        os.close();
-        reader.close();
-        if ((response == null) || response.startsWith("ERR") || response.startsWith("7")) {
-            if (response == null) {
-                response = "null";
-            } else if (response.startsWith("7")) {
-                response = response.substring(response.startsWith("7,") ? 2 : 1);
+        try {
+            try (OutputStream os = connection.getOutputStream()) {
+                os.write(compressed);
+                os.flush();
             }
-            throw new IOException(response);
-        } else {
-            // Is this the first update this hour?
-            if (response.equals("1") || response.contains("This is your first update this hour")) {
-                synchronized (this.graphs) {
-                    for (final Graph graph : this.graphs) {
-                        for (final Plotter plotter : graph.getPlotters()) {
-                            plotter.reset();
+            String response;
+            try (BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
+                response = reader.readLine();
+                if (this.debug) {
+                    PS.debug("[Metrics] Response for " + pluginName + ": " + response);
+                }
+            }
+            if (response == null || response.startsWith("ERR") || response.startsWith("7")) {
+                if (response == null) {
+                    response = "null";
+                } else if (response.startsWith("7")) {
+                    response = response.substring(response.startsWith("7,") ? 2 : 1);
+                }
+                throw new IOException(response);
+            } else {
+                // Is this the first update this hour?
+                if ("1".equals(response) || response.contains("This is your first update this hour")) {
+                    synchronized (this.graphs) {
+                        for (Graph graph : this.graphs) {
+                            for (Plotter plotter : graph.getPlotters()) {
+                                plotter.reset();
+                            }
                         }
                     }
                 }
             }
+        } catch (Exception e) {
+            if (this.debug) {
+                e.printStackTrace();
+            }
         }
     }
 
@@ -567,7 +446,7 @@ public class Metrics {
         try {
             Class.forName("mineshafter.MineServer");
             return true;
-        } catch (final Exception e) {
+        } catch (ClassNotFoundException e) {
             return false;
         }
     }
@@ -576,6 +455,7 @@ public class Metrics {
      * Represents a custom graph on the website
      */
     public static class Graph {
+
         /**
          * The graph's name, alphanumeric and spaces only :) If it does not comply to the above when submitted, it is
          * rejected
@@ -584,9 +464,9 @@ public class Metrics {
         /**
          * The set of plotters that are contained within this graph
          */
-        private final Set<Plotter> plotters = new LinkedHashSet<Plotter>();
+        private final Set<Plotter> plotters = new LinkedHashSet<>();
 
-        private Graph(final String name) {
+        private Graph(String name) {
             this.name = name;
         }
 
@@ -604,7 +484,7 @@ public class Metrics {
          *
          * @param plotter the plotter to add to the graph
          */
-        public void addPlotter(final Plotter plotter) {
+        public void addPlotter(Plotter plotter) {
             this.plotters.add(plotter);
         }
 
@@ -613,7 +493,7 @@ public class Metrics {
          *
          * @param plotter the plotter to remove from the graph
          */
-        public void removePlotter(final Plotter plotter) {
+        public void removePlotter(Plotter plotter) {
             this.plotters.remove(plotter);
         }
 
@@ -632,11 +512,11 @@ public class Metrics {
         }
 
         @Override
-        public boolean equals(final Object object) {
+        public boolean equals(Object object) {
             if (!(object instanceof Graph)) {
                 return false;
             }
-            final Graph graph = (Graph) object;
+            Graph graph = (Graph) object;
             return graph.name.equals(this.name);
         }
 
@@ -650,7 +530,8 @@ public class Metrics {
     /**
      * Interface used to collect custom data for a plugin
      */
-    public static abstract class Plotter {
+    public abstract static class Plotter {
+
         /**
          * The plot's name
          */
@@ -668,7 +549,7 @@ public class Metrics {
          *
          * @param name the name of the plotter to use, which will show up on the website
          */
-        public Plotter(final String name) {
+        public Plotter(String name) {
             this.name = name;
         }
 
@@ -702,12 +583,12 @@ public class Metrics {
         }
 
         @Override
-        public boolean equals(final Object object) {
+        public boolean equals(Object object) {
             if (!(object instanceof Plotter)) {
                 return false;
             }
-            final Plotter plotter = (Plotter) object;
-            return plotter.name.equals(this.name) && (plotter.getValue() == getValue());
+            Plotter plotter = (Plotter) object;
+            return plotter.name.equals(this.name) && plotter.getValue() == getValue();
         }
     }
-}
+}

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

@@ -8,26 +8,26 @@ import static com.intellectualcrafters.plot.util.ReflectionUtils.getUtilClass;
 import static com.intellectualcrafters.plot.util.ReflectionUtils.makeConstructor;
 import static com.intellectualcrafters.plot.util.ReflectionUtils.makeMethod;
 
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-import java.util.UUID;
-
 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;
+
 public class OfflinePlayerUtil {
 
-    public static Player loadPlayer(final String name) {
+    public static Player loadPlayer(String name) {
         return loadPlayer(Bukkit.getOfflinePlayer(name));
     }
 
-    public static Player loadPlayer(final UUID id) {
+    public static Player loadPlayer(UUID id) {
         return loadPlayer(Bukkit.getOfflinePlayer(id));
     }
 
-    public static Player loadPlayer(final OfflinePlayer player) {
+    public static Player loadPlayer(OfflinePlayer player) {
         if (player == null) {
             return null;
         }
@@ -37,26 +37,26 @@ public class OfflinePlayerUtil {
         return loadPlayer(player.getUniqueId(), player.getName());
     }
 
-    private static Player loadPlayer(final UUID id, final String name) {
-        final Object server = getMinecraftServer();
-        final Object interactManager = newPlayerInteractManager();
-        final Object worldServer = getWorldServer();
-        final Object profile = newGameProfile(id, name);
-        final Class<?> entityPlayerClass = getNmsClass("EntityPlayer");
-        final Constructor entityPlayerConstructor = makeConstructor(entityPlayerClass, getNmsClass("MinecraftServer"), getNmsClass("WorldServer"), getUtilClass("com.mojang.authlib.GameProfile"), getNmsClass("PlayerInteractManager"));
-        final Object entityPlayer = callConstructor(entityPlayerConstructor, server, worldServer, profile, interactManager);
-        final Player player = (Player) getBukkitEntity(entityPlayer);
-        return player;
+    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(final UUID id, final String name) {
-        final Class<?> gameProfileClass = getUtilClass("com.mojang.authlib.GameProfile");
+    private static Object newGameProfile(UUID id, String name) {
+        Class<?> gameProfileClass = getUtilClass("com.mojang.authlib.GameProfile");
         if (gameProfileClass == null) { //Before uuids
             return name;
         }
-        Constructor gameProfileConstructor = null;
-        gameProfileConstructor = makeConstructor(gameProfileClass, UUID.class, String.class);
-        if (gameProfileConstructor == null) { //Verson has string constructor
+        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
@@ -65,17 +65,17 @@ public class OfflinePlayerUtil {
     }
 
     private static Object newPlayerInteractManager() {
-        final Object worldServer = getWorldServer();
-        final Class<?> playerInteractClass = getNmsClass("PlayerInteractManager");
-        final Class<?> worldClass = getNmsClass("World");
-        final Constructor c = makeConstructor(playerInteractClass, worldClass);
+        Object worldServer = getWorldServer();
+        Class<?> playerInteractClass = getNmsClass("PlayerInteractManager");
+        Class<?> worldClass = getNmsClass("World");
+        Constructor c = makeConstructor(playerInteractClass, worldClass);
         return callConstructor(c, worldServer);
     }
 
     private static Object getWorldServer() {
-        final Object server = getMinecraftServer();
-        final Class<?> minecraftServerClass = getNmsClass("MinecraftServer");
-        final Method getWorldServer = makeMethod(minecraftServerClass, "getWorldServer", int.class);
+        Object server = getMinecraftServer();
+        Class<?> minecraftServerClass = getNmsClass("MinecraftServer");
+        Method getWorldServer = makeMethod(minecraftServerClass, "getWorldServer", int.class);
         return callMethod(getWorldServer, server, 0);
     }
 
@@ -85,8 +85,8 @@ public class OfflinePlayerUtil {
         return callMethod(makeMethod(getCbClass("CraftServer"), "getServer"), Bukkit.getServer());
     }
 
-    private static Entity getBukkitEntity(final Object o) {
-        final Method getBukkitEntity = makeMethod(o.getClass(), "getBukkitEntity");
+    private static Entity getBukkitEntity(Object o) {
+        Method getBukkitEntity = makeMethod(o.getClass(), "getBukkitEntity");
         return callMethod(getBukkitEntity, o);
     }
 }

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

@@ -0,0 +1,140 @@
+package com.plotsquared.bukkit.util;
+
+import static com.intellectualcrafters.plot.util.ReflectionUtils.getRefClass;
+
+import com.intellectualcrafters.plot.PS;
+import com.intellectualcrafters.plot.object.ChunkLoc;
+import com.intellectualcrafters.plot.object.Location;
+import com.intellectualcrafters.plot.object.Plot;
+import com.intellectualcrafters.plot.object.PlotPlayer;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefClass;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefConstructor;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefField;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefMethod;
+import com.intellectualcrafters.plot.util.TaskManager;
+import com.intellectualcrafters.plot.util.UUIDHandler;
+import com.plotsquared.bukkit.object.BukkitPlayer;
+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;
+
+/**
+ * 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() {
+        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(), boolean.class, 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<Chunk>(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.get(world);
+            if (list == null) {
+                list = new ArrayList<>();
+                map.put(world, list);
+            }
+            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 loc = null;
+            String world;
+            if (plot != null) {
+                world = plot.getArea().worldname;
+            } else {
+                loc = pp.getLocation();
+                world = loc.getWorld();
+            }
+            ArrayList<Chunk> list = map.get(world);
+            if (list == null) {
+                continue;
+            }
+            if (loc == null) {
+                loc = pp.getLocation();
+            }
+            int cx = loc.getX() >> 4;
+            int cz = loc.getZ() >> 4;
+            Player player = ((BukkitPlayer) pp).player;
+            Object entity = this.methodGetHandlePlayer.of(player).call();
+
+            for (Chunk chunk : list) {
+                int dx = Math.abs(cx - chunk.getX());
+                int dz = Math.abs(cz - 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 = this.mapChunk.create(c, true, 65535);
+                this.send.of(con).call(packet);
+            }
+        }
+        for (final Chunk chunk : chunks) {
+            TaskManager.runTask(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        chunk.unload(true, false);
+                    } catch (Throwable e) {
+                        String worldName = chunk.getWorld().getName();
+                        PS.debug("$4Could not save chunk: " + worldName + ";" + chunk.getX() + ";" + chunk.getZ());
+                        PS.debug("$3 - $4File may be open in another process (e.g. MCEdit)");
+                        PS.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<ChunkLoc> chunkLocations) {
+        World myWorld = Bukkit.getWorld(worldName);
+        ArrayList<Chunk> chunks = new ArrayList<>();
+        for (ChunkLoc loc : chunkLocations) {
+            if (myWorld.isChunkLoaded(loc.x, loc.z)) {
+                chunks.add(myWorld.getChunkAt(loc.x, loc.z));
+            }
+        }
+        sendChunk(chunks);
+    }
+}

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

@@ -1,31 +1,33 @@
 package com.plotsquared.bukkit.util;
 
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.Iterator;
-
+import com.intellectualcrafters.plot.PS;
+import com.intellectualcrafters.plot.generator.GeneratorWrapper;
+import com.intellectualcrafters.plot.util.SetupUtils;
+import com.plotsquared.bukkit.generator.BukkitAugmentedGenerator;
 import org.bukkit.World;
 import org.bukkit.generator.BlockPopulator;
 import org.bukkit.generator.ChunkGenerator;
 
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.generator.PlotGenerator;
-import com.intellectualcrafters.plot.util.SetupUtils;
-import com.plotsquared.bukkit.generator.AugmentedPopulator;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Iterator;
 
 public class SetGenCB {
+
     public static void setGenerator(World world) throws Exception {
         SetupUtils.manager.updateGenerators();
-        PS.get().removePlotWorldAbs(world.getName());
+        PS.get().removePlotAreas(world.getName());
         ChunkGenerator gen = world.getGenerator();
         if (gen == null) {
             return;
         }
         String name = gen.getClass().getCanonicalName();
         boolean set = false;
-        for (PlotGenerator<?> wrapper : SetupUtils.generators.values()) {
-            ChunkGenerator newGen = (ChunkGenerator) wrapper.generator;
+        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");
@@ -35,20 +37,18 @@ public class SetGenCB {
                 // Set populators (just in case)
                 populators.set(world, new ArrayList<>());
                 // Set generator
-                Constructor<? extends ChunkGenerator> constructor = newGen.getClass().getConstructor(String.class);
-                ChunkGenerator newNewGen = constructor.newInstance(world.getName());
-                generator.set(world, newNewGen);
-                populators.set(world, newNewGen.getDefaultPopulators(world));
+                generator.set(world, newGen);
+                populators.set(world, newGen.getDefaultPopulators(world));
                 // end
                 set = true;
                 break;
             }
         }
         if (!set) {
-            Iterator<BlockPopulator> iter = world.getPopulators().iterator();
-            while (iter.hasNext()) {
-                if (iter.next() instanceof AugmentedPopulator) {
-                    iter.remove();
+            Iterator<BlockPopulator> iterator = world.getPopulators().iterator();
+            while (iterator.hasNext()) {
+                if (iterator.next() instanceof BukkitAugmentedGenerator) {
+                    iterator.remove();
                 }
             }
         }

Bukkit/src/main/java/com/plotsquared/bukkit/util/block/FastChunk_1_8_3.java

@@ -0,0 +1,247 @@
+package com.plotsquared.bukkit.util.block;
+
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.PlotChunk;
+import com.intellectualcrafters.plot.util.SetQueue.ChunkWrapper;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+
+import java.util.Arrays;
+
+public class FastChunk_1_8_3 extends PlotChunk<Chunk> {
+
+    public char[][] ids;
+    public short[] count;
+    public short[] air;
+    public short[] relight;
+    public int[][] biomes;
+    public Chunk chunk;
+
+    public FastChunk_1_8_3(ChunkWrapper chunk) {
+        super(chunk);
+        this.ids = new char[16][];
+        this.count = new short[16];
+        this.air = new short[16];
+        this.relight = new short[16];
+    }
+
+    @Override
+    public Chunk getChunkAbs() {
+        ChunkWrapper loc = getChunkWrapper();
+        return BukkitUtil.getWorld(loc.world).getChunkAt(loc.x, loc.z);
+    }
+
+    @Override
+    public Chunk getChunk() {
+        if (this.chunk == null) {
+            ChunkWrapper cl = getChunkWrapper();
+            this.chunk = Bukkit.getWorld(cl.world).getChunkAt(cl.x, cl.z);
+        }
+        return this.chunk;
+    }
+
+    @Override
+    public void setChunkWrapper(ChunkWrapper loc) {
+        super.setChunkWrapper(loc);
+        this.chunk = null;
+    }
+
+    /**
+     * Get the number of block changes in a specified section.
+     * @param i
+     * @return
+     */
+    public int getCount(int i) {
+        return this.count[i];
+    }
+
+    public int getAir(int i) {
+        return this.air[i];
+    }
+
+    public void setCount(int i, short value) {
+        this.count[i] = value;
+    }
+
+    /**
+     * Get the number of block changes in a specified section.
+     * @param i
+     * @return
+     */
+    public int getRelight(int i) {
+        return this.relight[i];
+    }
+
+    public int getTotalCount() {
+        int total = 0;
+        for (int i = 0; i < 16; i++) {
+            total += this.count[i];
+        }
+        return total;
+    }
+
+    public int getTotalRelight() {
+        if (getTotalCount() == 0) {
+            Arrays.fill(this.count, (short) 1);
+            Arrays.fill(this.relight, Short.MAX_VALUE);
+            return Short.MAX_VALUE;
+        }
+        int total = 0;
+        for (int i = 0; i < 16; i++) {
+            total += this.relight[i];
+        }
+        return total;
+    }
+
+    /**
+     * Get the raw data for a section.
+     * @param i
+     * @return
+     */
+    public char[] getIdArray(int i) {
+        return this.ids[i];
+    }
+
+    @Override
+    public void setBlock(int x, int y, int z, int id, byte data) {
+        int i = MainUtil.CACHE_I[y][x][z];
+        int j = MainUtil.CACHE_J[y][x][z];
+        char[] vs = this.ids[i];
+        if (vs == null) {
+            vs = this.ids[i] = new char[4096];
+            this.count[i]++;
+        } else if (vs[j] == 0) {
+            this.count[i]++;
+        }
+        switch (id) {
+            case 0:
+                this.air[i]++;
+                vs[j] = (char) 1;
+                return;
+            case 10:
+            case 11:
+            case 39:
+            case 40:
+            case 51:
+            case 74:
+            case 89:
+            case 122:
+            case 124:
+            case 138:
+            case 169:
+                this.relight[i]++;
+            case 2:
+            case 4:
+            case 13:
+            case 14:
+            case 15:
+            case 20:
+            case 21:
+            case 22:
+            case 30:
+            case 32:
+            case 37:
+            case 41:
+            case 42:
+            case 45:
+            case 46:
+            case 47:
+            case 48:
+            case 49:
+            case 55:
+            case 56:
+            case 57:
+            case 58:
+            case 60:
+            case 7:
+            case 8:
+            case 9:
+            case 73:
+            case 78:
+            case 79:
+            case 80:
+            case 81:
+            case 82:
+            case 83:
+            case 85:
+            case 87:
+            case 88:
+            case 101:
+            case 102:
+            case 103:
+            case 110:
+            case 112:
+            case 113:
+            case 121:
+            case 129:
+            case 133:
+            case 165:
+            case 166:
+            case 170:
+            case 172:
+            case 173:
+            case 174:
+            case 181:
+            case 182:
+            case 188:
+            case 189:
+            case 190:
+            case 191:
+            case 192:
+                vs[j] = (char) (id << 4);
+                return;
+            case 130:
+            case 76:
+            case 62:
+                this.relight[i]++;
+            case 54:
+            case 146:
+            case 61:
+            case 65:
+            case 68:
+            case 50:
+                if (data < 2) {
+                    data = 2;
+                }
+            default:
+                vs[j] = (char) ((id << 4) + data);
+                return;
+        }
+    }
+
+    @Override
+    public PlotChunk clone() {
+        FastChunk_1_8_3 toReturn = new FastChunk_1_8_3(getChunkWrapper());
+        toReturn.air = this.air.clone();
+        toReturn.count = this.count.clone();
+        toReturn.relight = this.relight.clone();
+        toReturn.ids = new char[this.ids.length][];
+        for (int i = 0; i < this.ids.length; i++) {
+            char[] matrix = this.ids[i];
+            if (matrix != null) {
+                toReturn.ids[i] = new char[matrix.length];
+                System.arraycopy(matrix, 0, toReturn.ids[i], 0, matrix.length);
+            }
+        }
+        return toReturn;
+    }
+
+    @Override
+    public PlotChunk shallowClone() {
+        FastChunk_1_8_3 toReturn = new FastChunk_1_8_3(getChunkWrapper());
+        toReturn.air = this.air;
+        toReturn.count = this.count;
+        toReturn.relight = this.relight;
+        toReturn.ids = this.ids;
+        return toReturn;
+    }
+
+    @Override
+    public void setBiome(int x, int z, int biome) {
+        if (this.biomes == null) {
+            this.biomes = new int[16][16];
+        }
+        this.biomes[x][z] = biome;
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/block/FastChunk_1_9.java

@@ -0,0 +1,251 @@
+package com.plotsquared.bukkit.util.block;
+
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.PlotChunk;
+import com.intellectualcrafters.plot.util.SetQueue.ChunkWrapper;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+
+import java.util.Arrays;
+
+public class FastChunk_1_9 extends PlotChunk<Chunk> {
+
+    public int[][] ids;
+    public short[] count;
+    public short[] air;
+    public short[] relight;
+    public int[][] biomes;
+    public Chunk chunk;
+
+    public FastChunk_1_9(ChunkWrapper chunk) {
+        super(chunk);
+        this.ids = new int[16][];
+        this.count = new short[16];
+        this.air = new short[16];
+        this.relight = new short[16];
+    }
+
+    @Override
+    public Chunk getChunkAbs() {
+        ChunkWrapper loc = getChunkWrapper();
+        return BukkitUtil.getWorld(loc.world).getChunkAt(loc.x, loc.z);
+    }
+
+    @Override
+    public Chunk getChunk() {
+        if (this.chunk == null) {
+            ChunkWrapper cl = getChunkWrapper();
+            this.chunk = Bukkit.getWorld(cl.world).getChunkAt(cl.x, cl.z);
+        }
+        return this.chunk;
+    }
+
+    @Override
+    public void setChunkWrapper(ChunkWrapper loc) {
+        super.setChunkWrapper(loc);
+        this.chunk = null;
+    }
+
+    /**
+     * Get the number of block changes in a specified section.
+     * @param i
+     * @return
+     */
+    public int getCount(int i) {
+        return this.count[i];
+    }
+
+    public int getAir(int i) {
+        return this.air[i];
+    }
+
+    public void setCount(int i, short value) {
+        this.count[i] = value;
+    }
+
+    /**
+     * Get the number of block changes in a specified section.
+     * @param i
+     * @return
+     */
+    public int getRelight(int i) {
+        return this.relight[i];
+    }
+
+    public int getTotalCount() {
+        int total = 0;
+        for (int i = 0; i < 16; i++) {
+            total += this.count[i];
+        }
+        return total;
+    }
+
+    public int getTotalRelight() {
+        if (getTotalCount() == 0) {
+            Arrays.fill(this.count, (short) 1);
+            Arrays.fill(this.relight, Short.MAX_VALUE);
+            return Short.MAX_VALUE;
+        }
+        int total = 0;
+        for (int i = 0; i < 16; i++) {
+            total += this.relight[i];
+        }
+        return total;
+    }
+
+    /**
+     * Get the raw data for a section.
+     * @param i
+     * @return
+     */
+    public int[] getIdArray(int i) {
+        return this.ids[i];
+    }
+
+    public int[][] getIdArrays() {
+        return this.ids;
+    }
+
+    @Override
+    public void setBlock(int x, int y, int z, int id, byte data) {
+        int i = MainUtil.CACHE_I[y][x][z];
+        int j = MainUtil.CACHE_J[y][x][z];
+        int[] vs = this.ids[i];
+        if (vs == null) {
+            vs = this.ids[i] = new int[4096];
+            this.count[i]++;
+        } else if (vs[j] == 0) {
+            this.count[i]++;
+        }
+        switch (id) {
+            case 0:
+                this.air[i]++;
+                vs[j] = -1;
+                return;
+            case 10:
+            case 11:
+            case 39:
+            case 40:
+            case 51:
+            case 74:
+            case 89:
+            case 122:
+            case 124:
+            case 138:
+            case 169:
+                this.relight[i]++;
+            case 2:
+            case 4:
+            case 13:
+            case 14:
+            case 15:
+            case 20:
+            case 21:
+            case 22:
+            case 30:
+            case 32:
+            case 37:
+            case 41:
+            case 42:
+            case 45:
+            case 46:
+            case 47:
+            case 48:
+            case 49:
+            case 55:
+            case 56:
+            case 57:
+            case 58:
+            case 60:
+            case 7:
+            case 8:
+            case 9:
+            case 73:
+            case 78:
+            case 79:
+            case 80:
+            case 81:
+            case 82:
+            case 83:
+            case 85:
+            case 87:
+            case 88:
+            case 101:
+            case 102:
+            case 103:
+            case 110:
+            case 112:
+            case 113:
+            case 121:
+            case 129:
+            case 133:
+            case 165:
+            case 166:
+            case 170:
+            case 172:
+            case 173:
+            case 174:
+            case 181:
+            case 182:
+            case 188:
+            case 189:
+            case 190:
+            case 191:
+            case 192:
+                vs[j] = id;
+                return;
+            case 130:
+            case 76:
+            case 62:
+                this.relight[i]++;
+            case 54:
+            case 146:
+            case 61:
+            case 65:
+            case 68:
+            case 50:
+                if (data < 2) {
+                    data = 2;
+                }
+            default:
+                vs[j] = id + (data << 12);
+                return;
+        }
+    }
+
+    @Override
+    public PlotChunk clone() {
+        FastChunk_1_9 toReturn = new FastChunk_1_9(getChunkWrapper());
+        toReturn.air = this.air.clone();
+        toReturn.count = this.count.clone();
+        toReturn.relight = this.relight.clone();
+        toReturn.ids = new int[this.ids.length][];
+        for (int i = 0; i < this.ids.length; i++) {
+            int[] matrix = this.ids[i];
+            if (matrix != null) {
+                toReturn.ids[i] = new int[matrix.length];
+                System.arraycopy(matrix, 0, toReturn.ids[i], 0, matrix.length);
+            }
+        }
+        return toReturn;
+    }
+
+    @Override
+    public PlotChunk shallowClone() {
+        FastChunk_1_9 toReturn = new FastChunk_1_9(getChunkWrapper());
+        toReturn.air = this.air;
+        toReturn.count = this.count;
+        toReturn.relight = this.relight;
+        toReturn.ids = this.ids;
+        return toReturn;
+    }
+
+    @Override
+    public void setBiome(int x, int z, int biome) {
+        if (this.biomes == null) {
+            this.biomes = new int[16][16];
+        }
+        this.biomes[x][z] = biome;
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/block/FastQueue_1_7.java

@@ -0,0 +1,179 @@
+package com.plotsquared.bukkit.util.block;
+
+import static com.intellectualcrafters.plot.util.ReflectionUtils.getRefClass;
+
+import com.intellectualcrafters.plot.object.ChunkLoc;
+import com.intellectualcrafters.plot.object.PlotBlock;
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.PlotChunk;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefClass;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefMethod;
+import com.intellectualcrafters.plot.util.SetQueue;
+import com.intellectualcrafters.plot.util.SetQueue.ChunkWrapper;
+import com.intellectualcrafters.plot.util.TaskManager;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.bukkit.util.SendChunk;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map.Entry;
+
+public class FastQueue_1_7 extends SlowQueue {
+
+    private final RefClass classBlock = getRefClass("{nms}.Block");
+    private final RefClass classChunk = getRefClass("{nms}.Chunk");
+    private final RefClass classWorld = getRefClass("{nms}.World");
+    private final RefClass classCraftWorld = getRefClass("{cb}.CraftWorld");
+    private final RefMethod methodGetHandle;
+    private final RefMethod methodGetChunkAt;
+    private final RefMethod methodA;
+    private final RefMethod methodGetById;
+    private final RefMethod methodInitLighting;
+    private final SendChunk sendChunk;
+
+    private final HashMap<ChunkWrapper, Chunk> toUpdate = new HashMap<>();
+
+    public FastQueue_1_7() throws RuntimeException {
+        this.methodGetHandle = this.classCraftWorld.getMethod("getHandle");
+        this.methodGetChunkAt = this.classWorld.getMethod("getChunkAt", int.class, int.class);
+        this.methodA = this.classChunk.getMethod("a", int.class, int.class, int.class, this.classBlock, int.class);
+        this.methodGetById = this.classBlock.getMethod("getById", int.class);
+        this.methodInitLighting = this.classChunk.getMethod("initLighting");
+        this.sendChunk = new SendChunk();
+        TaskManager.runTaskRepeat(new Runnable() {
+            @Override
+            public void run() {
+                if (FastQueue_1_7.this.toUpdate.isEmpty()) {
+                    return;
+                }
+                int count = 0;
+                ArrayList<Chunk> chunks = new ArrayList<>();
+                Iterator<Entry<ChunkWrapper, Chunk>> i = FastQueue_1_7.this.toUpdate.entrySet().iterator();
+                while (i.hasNext() && (count < 128)) {
+                    chunks.add(i.next().getValue());
+                    i.remove();
+                    count++;
+                }
+                if (count == 0) {
+                    return;
+                }
+                update(chunks);
+            }
+        }, 1);
+        MainUtil.initCache();
+    }
+
+    public void update(Collection<Chunk> chunks) {
+        if (chunks.isEmpty()) {
+            return;
+        }
+        if (!MainUtil.canSendChunk) {
+            for (Chunk chunk : chunks) {
+                chunk.getWorld().refreshChunk(chunk.getX(), chunk.getZ());
+                chunk.unload(true, false);
+                chunk.load();
+            }
+            return;
+        }
+        try {
+            this.sendChunk.sendChunk(chunks);
+        } catch (Throwable e) {
+            e.printStackTrace();
+            MainUtil.canSendChunk = false;
+        }
+    }
+
+    /**
+     * This should be overridden by any specialized queues
+     * @param plotChunk
+     */
+    @Override
+    public void execute(PlotChunk<Chunk> plotChunk) {
+        SlowChunk sc = (SlowChunk) plotChunk;
+        Chunk chunk = plotChunk.getChunk();
+        ChunkWrapper wrapper = plotChunk.getChunkWrapper();
+        if (!this.toUpdate.containsKey(wrapper)) {
+            this.toUpdate.put(wrapper, chunk);
+        }
+        chunk.load(true);
+        World world = chunk.getWorld();
+        Object w = this.methodGetHandle.of(world).call();
+        Object c = this.methodGetChunkAt.of(w).call(wrapper.x, wrapper.z);
+        for (int i = 0; i < sc.result.length; i++) {
+            PlotBlock[] result2 = sc.result[i];
+            if (result2 == null) {
+                continue;
+            }
+            for (int j = 0; j < 4096; j++) {
+                int x = MainUtil.x_loc[i][j];
+                int y = MainUtil.y_loc[i][j];
+                int z = MainUtil.z_loc[i][j];
+                PlotBlock newBlock = result2[j];
+                if (newBlock.id == -1) {
+                    chunk.getBlock(x, y, z).setData(newBlock.data, false);
+                    continue;
+                }
+                Object block = this.methodGetById.call(newBlock.id);
+                this.methodA.of(c).call(x, y, z, block, newBlock.data);
+            }
+        }
+        int[][] biomes = sc.biomes;
+        Biome[] values = Biome.values();
+        if (biomes != null) {
+            for (int x = 0; x < 16; x++) {
+                int[] array = biomes[x];
+                if (array == null) {
+                    continue;
+                }
+                for (int z = 0; z < 16; z++) {
+                    int biome = array[z];
+                    if (biome == 0) {
+                        continue;
+                    }
+                    chunk.getBlock(x, 0, z).setBiome(values[biome]);
+                }
+            }
+        }
+    }
+
+    /**
+     * This should be overridden by any specialized queues
+     * @param wrap
+     */
+    @Override
+    public PlotChunk<Chunk> getChunk(ChunkWrapper wrap) {
+        return new SlowChunk(wrap);
+    }
+
+    /**
+     * This should be overridden by any specialized queues
+     * @param chunk
+     * @param fixAll
+     */
+    @Override
+    public boolean fixLighting(PlotChunk<Chunk> chunk, boolean fixAll) {
+        Object c = this.methodGetHandle.of(chunk.getChunk()).call();
+        this.methodInitLighting.of(c).call();
+        return true;
+    }
+
+    /**
+     * This should be overridden by any specialized queues
+     * @param world
+     * @param locations
+     */
+    @Override
+    public void sendChunk(String world, Collection<ChunkLoc> locations) {
+        World worldObj = BukkitUtil.getWorld(world);
+        for (ChunkLoc loc : locations) {
+            ChunkWrapper wrapper = SetQueue.IMP.new ChunkWrapper(world, loc.x, loc.z);
+            this.toUpdate.remove(wrapper);
+        }
+        this.sendChunk.sendChunk(world, locations);
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/block/FastQueue_1_8.java

@@ -0,0 +1,380 @@
+package com.plotsquared.bukkit.util.block;
+
+import static com.intellectualcrafters.plot.util.ReflectionUtils.getRefClass;
+
+import com.intellectualcrafters.plot.object.ChunkLoc;
+import com.intellectualcrafters.plot.object.PlotBlock;
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.PlotChunk;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefClass;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefConstructor;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefMethod;
+import com.intellectualcrafters.plot.util.SetQueue;
+import com.intellectualcrafters.plot.util.SetQueue.ChunkWrapper;
+import com.intellectualcrafters.plot.util.TaskManager;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.bukkit.util.SendChunk;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.block.Block;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map.Entry;
+
+public class FastQueue_1_8 extends SlowQueue {
+
+    private final RefMethod methodInitLighting;
+    private final RefClass classBlock = getRefClass("{nms}.Block");
+    private final RefClass classBlockPosition = getRefClass("{nms}.BlockPosition");
+    private final RefClass classIBlockData = getRefClass("{nms}.IBlockData");
+    private final RefClass classChunk = getRefClass("{nms}.Chunk");
+    private final RefClass classWorld = getRefClass("{nms}.World");
+    private final RefClass classCraftWorld = getRefClass("{cb}.CraftWorld");
+    private final HashMap<ChunkWrapper, Chunk> toUpdate = new HashMap<>();
+    private final RefMethod methodGetHandle;
+    private final RefMethod methodGetChunkAt;
+    private final RefMethod methodA;
+    private final RefMethod methodGetByCombinedId;
+    private final RefConstructor constructorBlockPosition;
+    private final SendChunk sendChunk;
+
+    public FastQueue_1_8() throws RuntimeException {
+        this.methodInitLighting = this.classChunk.getMethod("initLighting");
+        this.constructorBlockPosition = this.classBlockPosition.getConstructor(int.class, int.class, int.class);
+        this.methodGetByCombinedId = this.classBlock.getMethod("getByCombinedId", int.class);
+        this.methodGetHandle = this.classCraftWorld.getMethod("getHandle");
+        this.methodGetChunkAt = this.classWorld.getMethod("getChunkAt", int.class, int.class);
+        this.methodA = this.classChunk.getMethod("a", this.classBlockPosition, this.classIBlockData);
+        this.sendChunk = new SendChunk();
+        TaskManager.runTaskRepeat(new Runnable() {
+            @Override
+            public void run() {
+                if (FastQueue_1_8.this.toUpdate.isEmpty()) {
+                    return;
+                }
+                int count = 0;
+                ArrayList<Chunk> chunks = new ArrayList<Chunk>();
+                Iterator<Entry<ChunkWrapper, Chunk>> i = FastQueue_1_8.this.toUpdate.entrySet().iterator();
+                while (i.hasNext() && count < 128) {
+                    chunks.add(i.next().getValue());
+                    i.remove();
+                    count++;
+                }
+                if (count == 0) {
+                    return;
+                }
+                update(chunks);
+            }
+        }, 1);
+        MainUtil.initCache();
+    }
+
+    public void update(Collection<Chunk> chunks) {
+        if (chunks.isEmpty()) {
+            return;
+        }
+        if (!MainUtil.canSendChunk) {
+            for (Chunk chunk : chunks) {
+                chunk.getWorld().refreshChunk(chunk.getX(), chunk.getZ());
+                chunk.unload(true, false);
+                chunk.load();
+            }
+            return;
+        }
+        try {
+            this.sendChunk.sendChunk(chunks);
+        } catch (Throwable e) {
+            e.printStackTrace();
+            MainUtil.canSendChunk = false;
+        }
+    }
+
+    /**
+     * This should be overridden by any specialized queues.
+     * @param plotChunk
+     */
+    @Override
+    public void execute(PlotChunk<Chunk> plotChunk) {
+        SlowChunk sc = (SlowChunk) plotChunk;
+        Chunk chunk = plotChunk.getChunk();
+        ChunkWrapper wrapper = plotChunk.getChunkWrapper();
+        if (!this.toUpdate.containsKey(wrapper)) {
+            this.toUpdate.put(wrapper, chunk);
+        }
+        chunk.load(true);
+        World world = chunk.getWorld();
+        Object w = this.methodGetHandle.of(world).call();
+        Object c = this.methodGetChunkAt.of(w).call(wrapper.x, wrapper.z);
+        for (int i = 0; i < sc.result.length; i++) {
+            PlotBlock[] result2 = sc.result[i];
+            if (result2 == null) {
+                continue;
+            }
+            for (int j = 0; j < 4096; j++) {
+                int x = MainUtil.x_loc[i][j];
+                int y = MainUtil.y_loc[i][j];
+                int z = MainUtil.z_loc[i][j];
+                PlotBlock newBlock = result2[j];
+                if (newBlock.id == -1) {
+                    chunk.getBlock(x, y, z).setData(newBlock.data, false);
+                    continue;
+                }
+                // Start blockstate workaround //
+                switch (newBlock.id) {
+                    case 54:
+                    case 130:
+                    case 142:
+                    case 132:
+                    case 27:
+                    case 137:
+                    case 52:
+                    case 154:
+                    case 84:
+                    case 25:
+                    case 144:
+                    case 138:
+                    case 176:
+                    case 177:
+                    case 119:
+                    case 63:
+                    case 68:
+                    case 323:
+                    case 117:
+                    case 116:
+                    case 28:
+                    case 66:
+                    case 157:
+                    case 61:
+                    case 62:
+                    case 140:
+                    case 146:
+                    case 149:
+                    case 150:
+                    case 158:
+                    case 23:
+                    case 123:
+                    case 124:
+                    case 29:
+                    case 33:
+                    case 151:
+                    case 178:
+                        Block block = world.getBlockAt(x, y, z);
+                        if (block.getData() == newBlock.data) {
+                            if (block.getTypeId() != newBlock.id) {
+                                block.setTypeId(newBlock.id, false);
+                            }
+                        } else {
+                            if (block.getTypeId() == newBlock.id) {
+                                block.setData(newBlock.data, false);
+                            } else {
+                                block.setTypeIdAndData(newBlock.id, newBlock.data, false);
+                            }
+                        }
+                        continue;
+                }
+
+                // Start data value shortcut
+                Block block = world.getBlockAt(x, y, z);
+                int currentId = block.getTypeId();
+                if (currentId == newBlock.id) {
+                    switch (newBlock.id) {
+                        case 0:
+                        case 2:
+                        case 4:
+                        case 13:
+                        case 14:
+                        case 15:
+                        case 20:
+                        case 21:
+                        case 22:
+                        case 25:
+                        case 30:
+                        case 32:
+                        case 37:
+                        case 39:
+                        case 40:
+                        case 41:
+                        case 42:
+                        case 45:
+                        case 46:
+                        case 47:
+                        case 48:
+                        case 49:
+                        case 51:
+                        case 52:
+                        case 54:
+                        case 55:
+                        case 56:
+                        case 57:
+                        case 58:
+                        case 60:
+                        case 61:
+                        case 62:
+                        case 7:
+                        case 8:
+                        case 9:
+                        case 10:
+                        case 11:
+                        case 73:
+                        case 74:
+                        case 78:
+                        case 79:
+                        case 80:
+                        case 81:
+                        case 82:
+                        case 83:
+                        case 84:
+                        case 85:
+                        case 87:
+                        case 88:
+                        case 101:
+                        case 102:
+                        case 103:
+                        case 110:
+                        case 112:
+                        case 113:
+                        case 117:
+                        case 121:
+                        case 122:
+                        case 123:
+                        case 124:
+                        case 129:
+                        case 133:
+                        case 138:
+                        case 137:
+                        case 140:
+                        case 165:
+                        case 166:
+                        case 169:
+                        case 170:
+                        case 172:
+                        case 173:
+                        case 174:
+                        case 176:
+                        case 177:
+                        case 181:
+                        case 182:
+                        case 188:
+                        case 189:
+                        case 190:
+                        case 191:
+                        case 192:
+                            continue;
+                    }
+                    if (block.getData() == newBlock.data) {
+                        return;
+                    }
+                    block.setData(newBlock.data, false);
+                    return;
+                }
+                // blockstate
+                switch (currentId) {
+                    case 54:
+                    case 130:
+                    case 132:
+                    case 142:
+                    case 27:
+                    case 137:
+                    case 52:
+                    case 154:
+                    case 84:
+                    case 25:
+                    case 144:
+                    case 138:
+                    case 176:
+                    case 177:
+                    case 63:
+                    case 68:
+                    case 323:
+                    case 117:
+                    case 119:
+                    case 116:
+                    case 28:
+                    case 66:
+                    case 157:
+                    case 61:
+                    case 62:
+                    case 140:
+                    case 146:
+                    case 149:
+                    case 150:
+                    case 158:
+                    case 23:
+                    case 123:
+                    case 124:
+                    case 29:
+                    case 33:
+                    case 151:
+                    case 178:
+                        if (block.getData() == newBlock.data) {
+                            block.setTypeId(newBlock.id, false);
+                        } else {
+                            block.setTypeIdAndData(newBlock.id, newBlock.data, false);
+                        }
+                        continue;
+                }
+                // End blockstate workaround //
+
+                // check sign
+                Object pos = this.constructorBlockPosition.create(x, y, z);
+                Object combined = this.methodGetByCombinedId.call(newBlock.id + (newBlock.data << 12));
+                this.methodA.of(chunk).call(pos, combined);
+            }
+        }
+        int[][] biomes = sc.biomes;
+        Biome[] values = Biome.values();
+        if (biomes != null) {
+            for (int x = 0; x < 16; x++) {
+                int[] array = biomes[x];
+                if (array == null) {
+                    continue;
+                }
+                for (int z = 0; z < 16; z++) {
+                    int biome = array[z];
+                    if (biome == 0) {
+                        continue;
+                    }
+                    chunk.getBlock(x, 0, z).setBiome(values[biome]);
+                }
+            }
+        }
+    }
+
+    /**
+     * This should be overridden by any specialized queues.
+     * @param wrap
+     */
+    @Override
+    public PlotChunk<Chunk> getChunk(ChunkWrapper wrap) {
+        return new SlowChunk(wrap);
+    }
+
+    /**
+     * This should be overridden by any specialized queues.
+     * @param fixAll
+     */
+    @Override
+    public boolean fixLighting(PlotChunk<Chunk> chunk, boolean fixAll) {
+        Object c = this.methodGetHandle.of(chunk.getChunk()).call();
+        this.methodInitLighting.of(c).call();
+        return true;
+    }
+
+    /**
+     * This should be overridden by any specialized queues.
+     * @param locations
+     */
+    @Override
+    public void sendChunk(String world, Collection<ChunkLoc> locations) {
+        World worldObj = BukkitUtil.getWorld(world);
+        for (ChunkLoc loc : locations) {
+            ChunkWrapper wrapper = SetQueue.IMP.new ChunkWrapper(world, loc.x, loc.z);
+            this.toUpdate.remove(wrapper);
+        }
+        this.sendChunk.sendChunk(world, locations);
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/block/FastQueue_1_8_3.java

@@ -0,0 +1,414 @@
+package com.plotsquared.bukkit.util.block;
+
+import com.intellectualcrafters.plot.object.ChunkLoc;
+import com.intellectualcrafters.plot.object.PseudoRandom;
+import com.intellectualcrafters.plot.util.ChunkManager;
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.PlotChunk;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefClass;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefConstructor;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefField;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefMethod;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefMethod.RefExecutor;
+import com.intellectualcrafters.plot.util.SetQueue;
+import com.intellectualcrafters.plot.util.SetQueue.ChunkWrapper;
+import com.intellectualcrafters.plot.util.TaskManager;
+import com.plotsquared.bukkit.util.SendChunk;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map.Entry;
+import java.util.Set;
+import org.bukkit.Chunk;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.World.Environment;
+import org.bukkit.block.Biome;
+
+
+import static com.intellectualcrafters.plot.util.ReflectionUtils.getRefClass;
+
+public class FastQueue_1_8_3 extends SlowQueue {
+
+    private final SendChunk sendChunk;
+    private final HashMap<ChunkWrapper, Chunk> toUpdate = new HashMap<>();
+    private final RefMethod methodGetHandleChunk;
+    private final RefMethod methodInitLighting;
+    private final RefConstructor classBlockPositionConstructor;
+    private final RefConstructor classChunkSectionConstructor;
+    private final RefMethod methodX;
+    private final RefMethod methodAreNeighborsLoaded;
+    private final RefField fieldSections;
+    private final RefField fieldWorld;
+    private final RefMethod methodGetIdArray;
+    private final RefMethod methodGetWorld;
+    private final RefField tileEntityListTick;
+
+    public FastQueue_1_8_3() throws RuntimeException {
+        RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
+        this.methodGetHandleChunk = classCraftChunk.getMethod("getHandle");
+        RefClass classChunk = getRefClass("{nms}.Chunk");
+        this.methodInitLighting = classChunk.getMethod("initLighting");
+        RefClass classBlockPosition = getRefClass("{nms}.BlockPosition");
+        this.classBlockPositionConstructor = classBlockPosition.getConstructor(int.class, int.class, int.class);
+        RefClass classWorld = getRefClass("{nms}.World");
+        this.methodX = classWorld.getMethod("x", classBlockPosition.getRealClass());
+        this.fieldSections = classChunk.getField("sections");
+        this.fieldWorld = classChunk.getField("world");
+        RefClass classChunkSection = getRefClass("{nms}.ChunkSection");
+        this.methodGetIdArray = classChunkSection.getMethod("getIdArray");
+        this.methodAreNeighborsLoaded = classChunk.getMethod("areNeighborsLoaded", int.class);
+        this.classChunkSectionConstructor = classChunkSection.getConstructor(int.class, boolean.class, char[].class);
+        this.tileEntityListTick = classWorld.getField("tileEntityList");
+        this.methodGetWorld = classChunk.getMethod("getWorld");
+        this.sendChunk = new SendChunk();
+        TaskManager.runTaskRepeat(new Runnable() {
+            @Override
+            public void run() {
+                if (FastQueue_1_8_3.this.toUpdate.isEmpty()) {
+                    return;
+                }
+                int count = 0;
+                ArrayList<Chunk> chunks = new ArrayList<>();
+                Iterator<Entry<ChunkWrapper, Chunk>> i = FastQueue_1_8_3.this.toUpdate.entrySet().iterator();
+                while (i.hasNext() && count < 128) {
+                    chunks.add(i.next().getValue());
+                    i.remove();
+                    count++;
+                }
+                if (count == 0) {
+                    return;
+                }
+                update(chunks);
+            }
+        }, 1);
+        MainUtil.initCache();
+    }
+
+    public void update(Collection<Chunk> chunks) {
+        if (chunks.isEmpty()) {
+            return;
+        }
+        if (!MainUtil.canSendChunk) {
+            for (Chunk chunk : chunks) {
+                chunk.getWorld().refreshChunk(chunk.getX(), chunk.getZ());
+                chunk.unload(true, false);
+                chunk.load();
+            }
+            return;
+        }
+        try {
+            this.sendChunk.sendChunk(chunks);
+        } catch (Throwable e) {
+            e.printStackTrace();
+            MainUtil.canSendChunk = false;
+        }
+    }
+
+    /**
+     * This should be overridden by any specialized queues.
+     * @param plotChunk
+     */
+    @Override
+    public void execute(PlotChunk<Chunk> plotChunk) {
+        FastChunk_1_8_3 fs = (FastChunk_1_8_3) plotChunk;
+        Chunk chunk = plotChunk.getChunk();
+        World world = chunk.getWorld();
+        ChunkWrapper wrapper = plotChunk.getChunkWrapper();
+        if (!this.toUpdate.containsKey(wrapper)) {
+            this.toUpdate.put(wrapper, chunk);
+        }
+        chunk.load(true);
+        try {
+            boolean flag = world.getEnvironment() == Environment.NORMAL;
+
+            // Sections
+            Method getHandle = chunk.getClass().getDeclaredMethod("getHandle");
+            Object c = getHandle.invoke(chunk);
+            Object w = this.methodGetWorld.of(c).call();
+            Class<? extends Object> clazz = c.getClass();
+            Field sections1 = clazz.getDeclaredField("sections");
+            sections1.setAccessible(true);
+            Field tileEntities = clazz.getDeclaredField("tileEntities");
+            Field entitySlices = clazz.getDeclaredField("entitySlices");
+            Object[] sections = (Object[]) sections1.get(c);
+            HashMap<?, ?> tiles = (HashMap<?, ?>) tileEntities.get(c);
+            Collection<?>[] entities = (Collection<?>[]) entitySlices.get(c);
+
+            Method getX = null;
+            Method getY = null;
+            Method getZ = null;
+
+            // Trim tiles
+            boolean removed = false;
+            Set<Entry<?, ?>> entrySet = (Set<Entry<?, ?>>) (Set<?>) tiles.entrySet();
+            Iterator<Entry<?, ?>> iterator = entrySet.iterator();
+            while (iterator.hasNext()) {
+                Entry<?, ?> tile = iterator.next();
+                Object pos = tile.getKey();
+                if (getX == null) {
+                    Class<? extends Object> clazz2 = pos.getClass().getSuperclass();
+                    getX = clazz2.getDeclaredMethod("getX");
+                    getY = clazz2.getDeclaredMethod("getY");
+                    getZ = clazz2.getDeclaredMethod("getZ");
+                }
+                int lx = (int) getX.invoke(pos) & 15;
+                int ly = (int) getY.invoke(pos);
+                int lz = (int) getZ.invoke(pos) & 15;
+                int j = MainUtil.CACHE_I[ly][lx][lz];
+                int k = MainUtil.CACHE_J[ly][lx][lz];
+                char[] array = fs.getIdArray(j);
+                if (array == null) {
+                    continue;
+                }
+                if (array[k] != 0) {
+                    removed = true;
+                    iterator.remove();
+                }
+            }
+            if (removed) {
+                ((Collection) this.tileEntityListTick.of(w).get()).clear();
+            }
+
+            // Trim entities
+            for (int i = 0; i < 16; i++) {
+                if ((entities[i] != null) && (fs.getCount(i) >= 4096)) {
+                    entities[i].clear();
+                }
+            }
+
+            // Efficiently merge sections
+            for (int j = 0; j < sections.length; j++) {
+                if (fs.getCount(j) == 0) {
+                    continue;
+                }
+                char[] newArray = fs.getIdArray(j);
+                if (newArray == null) {
+                    continue;
+                }
+                Object section = sections[j];
+                if ((section == null) || (fs.getCount(j) >= 4096)) {
+                    section = sections[j] = newChunkSection(j << 4, flag, newArray);
+                    continue;
+                }
+                char[] currentArray = getIdArray(section);
+                boolean fill = true;
+                for (int k = 0; k < newArray.length; k++) {
+                    char n = newArray[k];
+                    switch (n) {
+                        case 0:
+                            fill = false;
+                            continue;
+                        case 1:
+                            fill = false;
+                            currentArray[k] = 0;
+                            continue;
+                        default:
+                            currentArray[k] = n;
+                            continue;
+                    }
+                }
+                if (fill) {
+                    fs.setCount(j, Short.MAX_VALUE);
+                }
+            }
+            // Clear
+        } catch (IllegalAccessException | IllegalArgumentException | NoSuchMethodException | SecurityException | InvocationTargetException
+                | NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        int[][] biomes = fs.biomes;
+        Biome[] values = Biome.values();
+        if (biomes != null) {
+            for (int x = 0; x < 16; x++) {
+                int[] array = biomes[x];
+                if (array == null) {
+                    continue;
+                }
+                for (int z = 0; z < 16; z++) {
+                    int biome = array[z];
+                    if (biome == 0) {
+                        continue;
+                    }
+                    chunk.getBlock(x, 0, z).setBiome(values[biome]);
+                }
+            }
+        }
+    }
+
+    public Object newChunkSection(int i, boolean flag, char[] ids) {
+        return this.classChunkSectionConstructor.create(i, flag, ids);
+    }
+
+    public char[] getIdArray(Object obj) {
+        return (char[]) this.methodGetIdArray.of(obj).call();
+    }
+
+    /**
+     * This should be overridden by any specialized queues.
+     * @param wrap
+     */
+    @Override
+    public PlotChunk<Chunk> getChunk(ChunkWrapper wrap) {
+        return new FastChunk_1_8_3(wrap);
+    }
+
+    /**
+     * This should be overridden by any specialized queues
+     * @param plotChunk
+     */
+    @Override
+    public boolean fixLighting(PlotChunk<Chunk> plotChunk, boolean fixAll) {
+        try {
+            FastChunk_1_8_3 bc = (FastChunk_1_8_3) plotChunk;
+            Chunk chunk = bc.getChunk();
+            if (!chunk.isLoaded()) {
+                chunk.load(false);
+            } else {
+                chunk.unload(true, false);
+                chunk.load(false);
+            }
+
+            // Initialize lighting
+            Object c = this.methodGetHandleChunk.of(chunk).call();
+
+            if (fixAll && !(boolean) this.methodAreNeighborsLoaded.of(c).call(1)) {
+                World world = chunk.getWorld();
+                ChunkWrapper wrapper = bc.getChunkWrapper();
+                String worldName = wrapper.world;
+                for (int x = wrapper.x - 1; x <= wrapper.x + 1; x++) {
+                    for (int z = wrapper.z - 1; z <= wrapper.z + 1; z++) {
+                        if (x != 0 && z != 0) {
+                            Chunk other = world.getChunkAt(x, z);
+                            while (!other.isLoaded()) {
+                                other.load(true);
+                            }
+                            ChunkManager.manager.loadChunk(worldName, new ChunkLoc(x, z), true);
+                        }
+                    }
+                }
+/*
+                if (!(boolean) methodAreNeighborsLoaded.of(c).call(1)) {
+                    return false;
+                }
+*/
+            }
+
+            this.methodInitLighting.of(c).call();
+
+            if (bc.getTotalRelight() == 0 && !fixAll) {
+                return true;
+            }
+
+            Object[] sections = (Object[]) this.fieldSections.of(c).get();
+            Object w = this.fieldWorld.of(c).get();
+
+            int X = chunk.getX() << 4;
+            int Z = chunk.getZ() << 4;
+
+            RefExecutor relight = this.methodX.of(w);
+            for (int j = 0; j < sections.length; j++) {
+                Object section = sections[j];
+                if (section == null) {
+                    continue;
+                }
+                if ((bc.getRelight(j) == 0 && !fixAll) || bc.getCount(j) == 0 || (bc.getCount(j) >= 4096 && bc.getAir(j) == 0)) {
+                    continue;
+                }
+                char[] array = getIdArray(section);
+                int l = PseudoRandom.random.random(2);
+                for (int k = 0; k < array.length; k++) {
+                    int i = array[k];
+                    if (i < 16) {
+                        continue;
+                    }
+                    short id = (short) (i >> 4);
+                    switch (id) { // Lighting
+                        default:
+                            if (!fixAll) {
+                                continue;
+                            }
+                            if ((k & 1) == l) {
+                                l = 1 - l;
+                                continue;
+                            }
+                        case 10:
+                        case 11:
+                        case 39:
+                        case 40:
+                        case 50:
+                        case 51:
+                        case 62:
+                        case 74:
+                        case 76:
+                        case 89:
+                        case 122:
+                        case 124:
+                        case 130:
+                        case 138:
+                        case 169:
+                            int x = MainUtil.x_loc[j][k];
+                            int y = MainUtil.y_loc[j][k];
+                            int z = MainUtil.z_loc[j][k];
+                            if (isSurrounded(sections, x, y, z)) {
+                                continue;
+                            }
+                            Object pos = this.classBlockPositionConstructor.create(X + x, y, Z + z);
+                            relight.call(pos);
+                    }
+                }
+            }
+            return true;
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+        return false;
+    }
+
+    public boolean isSurrounded(Object[] sections, int x, int y, int z) {
+        return isSolid(getId(sections, x, y + 1, z))
+                && isSolid(getId(sections, x + 1, y - 1, z))
+                && isSolid(getId(sections, x - 1, y, z))
+                && isSolid(getId(sections, x, y, z + 1))
+                && isSolid(getId(sections, x, y, z - 1));
+    }
+
+    public boolean isSolid(int i) {
+        return i != 0 && Material.getMaterial(i).isOccluding();
+    }
+
+    public int getId(Object[] sections, int x, int y, int z) {
+        if (x < 0 || x > 15 || z < 0 || z > 15) {
+            return 1;
+        }
+        if (y < 0 || y > 255) {
+            return 1;
+        }
+        int i = MainUtil.CACHE_I[y][x][z];
+        Object section = sections[i];
+        if (section == null) {
+            return 0;
+        }
+        char[] array = getIdArray(section);
+        int j = MainUtil.CACHE_J[y][x][z];
+        return array[j] >> 4;
+    }
+
+    /**
+     * This should be overridden by any specialized queues.
+     * @param world
+     * @param locations
+     */
+    @Override
+    public void sendChunk(String world, Collection<ChunkLoc> locations) {
+        for (ChunkLoc loc : locations) {
+            ChunkWrapper wrapper = SetQueue.IMP.new ChunkWrapper(world, loc.x, loc.z);
+            this.toUpdate.remove(wrapper);
+        }
+        this.sendChunk.sendChunk(world, locations);
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/block/FastQueue_1_9.java

@@ -0,0 +1,422 @@
+package com.plotsquared.bukkit.util.block;
+
+import com.intellectualcrafters.plot.object.ChunkLoc;
+import com.intellectualcrafters.plot.object.PseudoRandom;
+import com.intellectualcrafters.plot.util.ChunkManager;
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.PlotChunk;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefClass;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefConstructor;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefField;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefMethod;
+import com.intellectualcrafters.plot.util.ReflectionUtils.RefMethod.RefExecutor;
+import com.intellectualcrafters.plot.util.SetQueue.ChunkWrapper;
+import com.intellectualcrafters.plot.util.TaskManager;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map.Entry;
+import java.util.Set;
+import org.bukkit.Chunk;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.World.Environment;
+import org.bukkit.block.Biome;
+
+
+import static com.intellectualcrafters.plot.util.ReflectionUtils.getRefClass;
+
+public class FastQueue_1_9 extends SlowQueue {
+
+    private final Object air;
+//    private final HashMap<ChunkWrapper, Chunk> toUpdate = new HashMap<>();
+    private final RefMethod methodGetHandleChunk;
+    private final RefMethod methodInitLighting;
+    private final RefConstructor classBlockPositionConstructor;
+    private final RefConstructor classChunkSectionConstructor;
+    private final RefMethod methodW;
+    private final RefMethod methodAreNeighborsLoaded;
+    private final RefField fieldSections;
+    private final RefField fieldWorld;
+    private final RefMethod methodGetBlocks;
+    private final RefMethod methodGetType;
+    private final RefMethod methodSetType;
+    private final RefMethod methodGetCombinedId;
+    private final RefMethod methodGetByCombinedId;
+    private final RefMethod methodGetWorld;
+
+    private final RefField tileEntityListTick;
+
+
+    public FastQueue_1_9() throws RuntimeException {
+        RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
+        this.methodGetHandleChunk = classCraftChunk.getMethod("getHandle");
+        RefClass classChunk = getRefClass("{nms}.Chunk");
+        this.methodInitLighting = classChunk.getMethod("initLighting");
+        RefClass classBlockPosition = getRefClass("{nms}.BlockPosition");
+        this.classBlockPositionConstructor = classBlockPosition.getConstructor(int.class, int.class, int.class);
+        RefClass classWorld = getRefClass("{nms}.World");
+        this.tileEntityListTick = classWorld.getField("tileEntityListTick");
+        this.methodGetWorld = classChunk.getMethod("getWorld");
+        this.methodW = classWorld.getMethod("w", classBlockPosition.getRealClass());
+        this.fieldSections = classChunk.getField("sections");
+        this.fieldWorld = classChunk.getField("world");
+        RefClass classBlock = getRefClass("{nms}.Block");
+        RefClass classIBlockData = getRefClass("{nms}.IBlockData");
+        this.methodGetCombinedId = classBlock.getMethod("getCombinedId", classIBlockData.getRealClass());
+        this.methodGetByCombinedId = classBlock.getMethod("getByCombinedId", int.class);
+        RefClass classChunkSection = getRefClass("{nms}.ChunkSection");
+        this.methodGetBlocks = classChunkSection.getMethod("getBlocks");
+        this.methodGetType = classChunkSection.getMethod("getType", int.class, int.class, int.class);
+        this.methodSetType = classChunkSection.getMethod("setType", int.class, int.class, int.class, classIBlockData.getRealClass());
+        this.methodAreNeighborsLoaded = classChunk.getMethod("areNeighborsLoaded", int.class);
+        this.classChunkSectionConstructor = classChunkSection.getConstructor(int.class, boolean.class, char[].class);
+        this.air = this.methodGetByCombinedId.call(0);
+        MainUtil.initCache();
+    }
+
+    /**
+     * This should be overridden by any specialized queues
+     * @param plotChunk
+     */
+    @Override
+    public void execute(final PlotChunk<Chunk> plotChunk) {
+        final FastChunk_1_9 fs = (FastChunk_1_9) plotChunk;
+        Chunk chunk = plotChunk.getChunk();
+        World world = chunk.getWorld();
+        ChunkWrapper wrapper = plotChunk.getChunkWrapper();
+        chunk.load(true);
+        try {
+            boolean flag = world.getEnvironment() == Environment.NORMAL;
+
+            // Sections
+            Method getHandle = chunk.getClass().getDeclaredMethod("getHandle");
+            Object c = getHandle.invoke(chunk);
+            Object w = this.methodGetWorld.of(c).call();
+            Class<? extends Object> clazz = c.getClass();
+            Field sf = clazz.getDeclaredField("sections");
+            sf.setAccessible(true);
+            Field tf = clazz.getDeclaredField("tileEntities");
+            Field entitySlices = clazz.getDeclaredField("entitySlices");
+            Object[] sections = (Object[]) sf.get(c);
+            HashMap<?, ?> tiles = (HashMap<?, ?>) tf.get(c);
+            Collection<?>[] entities = (Collection<?>[]) entitySlices.get(c);
+
+            Method xm = null;
+            Method ym = null;
+            Method zm = null;
+            // Trim tiles
+            boolean removed = false;
+            Set<Entry<?, ?>> entrySet = (Set<Entry<?, ?>>) (Set<?>) tiles.entrySet();
+            Iterator<Entry<?, ?>> iterator = entrySet.iterator();
+            while (iterator.hasNext()) {
+                Entry<?, ?> tile = iterator.next();
+                Object pos = tile.getKey();
+                if (xm == null) {
+                    Class<? extends Object> clazz2 = pos.getClass().getSuperclass();
+                    xm = clazz2.getDeclaredMethod("getX");
+                    ym = clazz2.getDeclaredMethod("getY");
+                    zm = clazz2.getDeclaredMethod("getZ");
+                }
+                int lx = (int) xm.invoke(pos) & 15;
+                int ly = (int) ym.invoke(pos);
+                int lz = (int) zm.invoke(pos) & 15;
+                int j = MainUtil.CACHE_I[ly][lx][lz];
+                int k = MainUtil.CACHE_J[ly][lx][lz];
+                int[] array = fs.getIdArray(j);
+                if (array == null) {
+                    continue;
+                }
+                if (array[k] != 0) {
+                    removed = true;
+                    iterator.remove();
+                }
+            }
+            if (removed) {
+                ((Collection) this.tileEntityListTick.of(w).get()).clear();
+            }
+
+            // Trim entities
+            for (int i = 0; i < 16; i++) {
+                if (entities[i] != null && fs.getCount(i) >= 4096) {
+                    entities[i].clear();
+                }
+            }
+
+            // Efficiently merge sections
+            for (int j = 0; j < sections.length; j++) {
+                if (fs.getCount(j) == 0) {
+                    continue;
+                }
+                int[] newArray = fs.getIdArray(j);
+                if (newArray == null) {
+                    continue;
+                }
+                Object section = sections[j];
+                if (section == null || fs.getCount(j) >= 4096) {
+                    char[] array = new char[4096];
+                    for (int i = 0; i < newArray.length; i++) {
+                        int combined = newArray[i];
+                        int id = combined & 4095;
+                        int data = combined >> 12;
+                        array[i] = (char) ((id << 4) + data);
+                    }
+                    section = sections[j] = newChunkSection(j << 4, flag, array);
+                    continue;
+                }
+                Object currentArray = getBlocks(section);
+                RefExecutor setType = this.methodSetType.of(section);
+                boolean fill = true;
+                for (int k = 0; k < newArray.length; k++) {
+                    int n = newArray[k];
+                    switch (n) {
+                        case 0:
+                            fill = false;
+                            continue;
+                        case -1: {
+                            fill = false;
+                            int x = MainUtil.x_loc[j][k];
+                            int y = MainUtil.y_loc[j][k];
+                            int z = MainUtil.z_loc[j][k];
+                            setType.call(x, y & 15, z, this.air);
+                            continue;
+                        }
+                        default:
+                            int x = MainUtil.x_loc[j][k];
+                            int y = MainUtil.y_loc[j][k];
+                            int z = MainUtil.z_loc[j][k];
+                            Object iBlock = this.methodGetByCombinedId.call((int) n);
+                            setType.call(x, y & 15, z, iBlock);
+                    }
+                }
+                if (fill) {
+                    fs.setCount(j, Short.MAX_VALUE);
+                }
+            }
+            // Clear
+        } catch (IllegalAccessException | IllegalArgumentException | NoSuchMethodException | SecurityException | InvocationTargetException |
+                NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        int[][] biomes = fs.biomes;
+        Biome[] values = Biome.values();
+        if (biomes != null) {
+            for (int x = 0; x < 16; x++) {
+                int[] array = biomes[x];
+                if (array == null) {
+                    continue;
+                }
+                for (int z = 0; z < 16; z++) {
+                    int biome = array[z];
+                    if (biome == 0) {
+                        continue;
+                    }
+                    chunk.getBlock(x, 0, z).setBiome(values[biome]);
+                }
+            }
+        }
+        TaskManager.runTaskLater(new Runnable() {
+            @Override
+            public void run() {
+                sendChunk(fs.getChunkWrapper().world, Arrays.asList(new ChunkLoc(fs.getX(), fs.getZ())));
+            }
+        }, 1);
+    }
+
+    public Object newChunkSection(int i, boolean flag, char[] ids) {
+        return this.classChunkSectionConstructor.create(i, flag, ids);
+    }
+
+    public Object getBlocks(Object obj) {
+        return this.methodGetBlocks.of(obj).call();
+    }
+
+    /**
+     * This should be overridden by any specialized queues
+     * @param wrap
+     */
+    @Override
+    public PlotChunk<Chunk> getChunk(ChunkWrapper wrap) {
+        return new FastChunk_1_9(wrap);
+    }
+
+    /**
+     * This should be overridden by any specialized queues
+     * @param pc
+     */
+    @Override
+    public boolean fixLighting(PlotChunk<Chunk> pc, boolean fixAll) {
+        try {
+            FastChunk_1_9 bc = (FastChunk_1_9) pc;
+            Chunk chunk = bc.getChunk();
+            if (!chunk.isLoaded()) {
+                chunk.load(false);
+            } else {
+                chunk.unload(true, true);
+                chunk.load(false);
+            }
+
+            // Initialize lighting
+            Object c = this.methodGetHandleChunk.of(chunk).call();
+
+            if (fixAll && !(boolean) this.methodAreNeighborsLoaded.of(c).call(1)) {
+                World world = chunk.getWorld();
+                ChunkWrapper wrapper = bc.getChunkWrapper();
+                String worldName = wrapper.world;
+                for (int x = wrapper.x - 1; x <= wrapper.x + 1; x++) {
+                    for (int z = wrapper.z - 1; z <= wrapper.z + 1; z++) {
+                        if (x != 0 && z != 0) {
+                            Chunk other = world.getChunkAt(x, z);
+                            while (!other.isLoaded()) {
+                                other.load(true);
+                            }
+                            ChunkManager.manager.loadChunk(worldName, new ChunkLoc(x, z), true);
+                        }
+                    }
+                }
+            }
+
+            this.methodInitLighting.of(c).call();
+
+            if (bc.getTotalRelight() == 0 && !fixAll) {
+                return true;
+            }
+
+            Object[] sections = (Object[]) this.fieldSections.of(c).get();
+            Object w = this.fieldWorld.of(c).get();
+
+            int X = chunk.getX() << 4;
+            int Z = chunk.getZ() << 4;
+
+            RefExecutor relight = this.methodW.of(w);
+            for (int j = 0; j < sections.length; j++) {
+                Object section = sections[j];
+                if (section == null) {
+                    continue;
+                }
+                if (bc.getRelight(j) == 0 && !fixAll || bc.getCount(j) == 0 || bc.getCount(j) >= 4096 && bc.getAir(j) == 0) {
+                    continue;
+                }
+                int[] array = bc.getIdArray(j);
+                if (array != null) {
+                    int l = PseudoRandom.random.random(2);
+                    for (int k = 0; k < array.length; k++) {
+                        int i = array[k];
+                        if (i < 16) {
+                            continue;
+                        }
+                        short id = (short) (i >> 4);
+                        switch (id) { // Lighting
+                            default:
+                                if (!fixAll) {
+                                    continue;
+                                }
+                                if ((k & 1) == l) {
+                                    l = 1 - l;
+                                    continue;
+                                }
+                            case 10:
+                            case 11:
+                            case 39:
+                            case 40:
+                            case 50:
+                            case 51:
+                            case 62:
+                            case 74:
+                            case 76:
+                            case 89:
+                            case 122:
+                            case 124:
+                            case 130:
+                            case 138:
+                            case 169:
+                                int x = MainUtil.x_loc[j][k];
+                                int y = MainUtil.y_loc[j][k];
+                                int z = MainUtil.z_loc[j][k];
+                                if (isSurrounded(bc.getIdArrays(), x, y, z)) {
+                                    continue;
+                                }
+                                Object pos = this.classBlockPositionConstructor.create(X + x, y, Z + z);
+                                relight.call(pos);
+                        }
+                    }
+                }
+            }
+            return true;
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+        return false;
+    }
+
+    public boolean isSurrounded(int[][] sections, int x, int y, int z) {
+        return isSolid(getId(sections, x, y + 1, z))
+                && isSolid(getId(sections, x + 1, y - 1, z))
+                && isSolid(getId(sections, x - 1, y, z))
+                && isSolid(getId(sections, x, y, z + 1))
+                && isSolid(getId(sections, x, y, z - 1));
+    }
+
+    public boolean isSolid(int i) {
+        if (i != 0) {
+            Material material = Material.getMaterial(i);
+            return material != null && Material.getMaterial(i).isOccluding();
+        }
+        return false;
+    }
+
+    public int getId(int[][] sections, int x, int y, int z) {
+        if (x < 0 || x > 15 || z < 0 || z > 15) {
+            return 1;
+        }
+        if (y < 0 || y > 255) {
+            return 1;
+        }
+        int i = MainUtil.CACHE_I[y][x][z];
+        int[] section = sections[i];
+        if (section == null) {
+            return 0;
+        }
+        int j = MainUtil.CACHE_J[y][x][z];
+        return section[j];
+    }
+
+    public int getId(Object section, int x, int y, int z) {
+        int j = MainUtil.CACHE_J[y][x][z];
+        Object iBlock = this.methodGetType.of(section).call(x, y & 15, z);
+        return (int) this.methodGetCombinedId.call(iBlock);
+    }
+
+    public int getId(Object[] sections, int x, int y, int z) {
+        if (x < 0 || x > 15 || z < 0 || z > 15) {
+            return 1;
+        }
+        if (y < 0 || y > 255) {
+            return 1;
+        }
+        int i = MainUtil.CACHE_I[y][x][z];
+        Object section = sections[i];
+        if (section == null) {
+            return 0;
+        }
+        return getId(section, x, y, z);
+    }
+
+    /**
+     * This should be overridden by any specialized queues
+     * @param world
+     * @param locations
+     */
+    @Override
+    public void sendChunk(final String world, final Collection<ChunkLoc> locations) {
+        World worldObj = BukkitUtil.getWorld(world);
+        for (ChunkLoc loc : locations) {
+            worldObj.refreshChunk(loc.x, loc.z);
+        }
+    }
+}

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

@@ -0,0 +1,106 @@
+package com.plotsquared.bukkit.util.block;
+
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.PlotChunk;
+import com.intellectualcrafters.plot.util.SetQueue.ChunkWrapper;
+import com.plotsquared.bukkit.util.BukkitUtil;
+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;
+
+public class GenChunk extends PlotChunk<Chunk> {
+
+    public final Biome[] biomes;
+    public Chunk chunk;
+    public short[][] result;
+    public byte[][] result_data;
+    public ChunkData cd;
+    public BiomeGrid grid;
+
+    public GenChunk(Chunk chunk, ChunkWrapper wrap) {
+        super(wrap);
+        if ((this.chunk = chunk) == null && wrap != null) {
+            World world = BukkitUtil.getWorld(wrap.world);
+            if (world != null) {
+                chunk = world.getChunkAt(wrap.x, wrap.z);
+            }
+        }
+        this.biomes = Biome.values();
+    }
+
+    @Override
+    public Chunk getChunkAbs() {
+        ChunkWrapper wrap = getChunkWrapper();
+        if (this.chunk == null || wrap.x != this.chunk.getX() || wrap.z != this.chunk.getZ()) {
+            this.chunk = BukkitUtil.getWorld(wrap.world).getChunkAt(wrap.x, wrap.z);
+        }
+        return this.chunk;
+    }
+
+    @Override
+    public void setBiome(int x, int z, int biome) {
+        this.grid.setBiome(x, z, this.biomes[biome]);
+    }
+
+    public void setBiome(int x, int z, Biome biome) {
+        if (this.grid != null) {
+            this.grid.setBiome(x, z, biome);
+        }
+    }
+
+    @Override
+    public void setBlock(int x, int y, int z, int id, byte data) {
+        if (this.result == null) {
+            this.cd.setBlock(x, y, z, id, data);
+            return;
+        }
+        int i = MainUtil.CACHE_I[y][x][z];
+        short[] v = this.result[i];
+        if (v == null) {
+            this.result[i] = v = new short[4096];
+        }
+        int j = MainUtil.CACHE_J[y][x][z];
+        v[j] = (short) id;
+        if (data != 0) {
+            byte[] vd = this.result_data[i];
+            if (vd == null) {
+                this.result_data[i] = vd = new byte[4096];
+            }
+            vd[j] = data;
+        }
+    }
+
+    @Override
+    public PlotChunk clone() {
+        GenChunk toReturn = new GenChunk(getChunkAbs(), getChunkWrapper());
+        if (this.result != null) {
+            for (int i = 0; i < this.result.length; i++) {
+                short[] matrix = this.result[i];
+                if (matrix != null) {
+                    toReturn.result[i] = new short[matrix.length];
+                    System.arraycopy(matrix, 0, toReturn.result[i], 0, matrix.length);
+                }
+            }
+            for (int i = 0; i < this.result_data.length; i++) {
+                byte[] matrix = this.result_data[i];
+                if (matrix != null) {
+                    toReturn.result_data[i] = new byte[matrix.length];
+                    System.arraycopy(matrix, 0, toReturn.result_data[i], 0, matrix.length);
+                }
+            }
+        }
+        toReturn.cd = this.cd;
+        return toReturn;
+    }
+
+    @Override
+    public PlotChunk shallowClone() {
+        GenChunk toReturn = new GenChunk(getChunkAbs(), getChunkWrapper());
+        toReturn.result = this.result;
+        toReturn.result_data = this.result_data;
+        toReturn.cd = this.cd;
+        return toReturn;
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/block/SlowChunk.java

@@ -0,0 +1,60 @@
+package com.plotsquared.bukkit.util.block;
+
+import com.intellectualcrafters.plot.object.PlotBlock;
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.PlotChunk;
+import com.intellectualcrafters.plot.util.SetQueue.ChunkWrapper;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import org.bukkit.Chunk;
+
+public class SlowChunk extends PlotChunk<Chunk> {
+
+    public PlotBlock[][] result = new PlotBlock[16][];
+    public int[][] biomes;
+
+    public SlowChunk(ChunkWrapper chunk) {
+        super(chunk);
+    }
+
+    @Override
+    public Chunk getChunkAbs() {
+        ChunkWrapper loc = getChunkWrapper();
+        return BukkitUtil.getWorld(loc.world).getChunkAt(loc.x, loc.z);
+    }
+
+    @Override
+    public void setBiome(int x, int z, int biome) {
+        if (this.biomes == null) {
+            this.biomes = new int[16][16];
+        }
+        this.biomes[x][z] = biome;
+    }
+
+    @Override
+    public void setBlock(int x, int y, int z, int id, byte data) {
+        if (this.result[y >> 4] == null) {
+            this.result[y >> 4] = new PlotBlock[4096];
+        }
+        this.result[MainUtil.CACHE_I[y][x][z]][MainUtil.CACHE_J[y][x][z]] = new PlotBlock((short) id, data);
+    }
+
+    @Override
+    public PlotChunk clone() {
+        SlowChunk toReturn = new SlowChunk(getChunkWrapper());
+        for (int i = 0; i < this.result.length; i++) {
+            PlotBlock[] matrix = this.result[i];
+            if (matrix != null) {
+                toReturn.result[i] = new PlotBlock[matrix.length];
+                System.arraycopy(matrix, 0, toReturn.result[i], 0, matrix.length);
+            }
+        }
+        return toReturn;
+    }
+
+    @Override
+    public PlotChunk shallowClone() {
+        SlowChunk toReturn = new SlowChunk(getChunkWrapper());
+        toReturn.result = this.result;
+        return toReturn;
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/block/SlowQueue.java

@@ -0,0 +1,280 @@
+package com.plotsquared.bukkit.util.block;
+
+import com.intellectualcrafters.plot.PS;
+import com.intellectualcrafters.plot.object.ChunkLoc;
+import com.intellectualcrafters.plot.object.PlotBlock;
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.PlotChunk;
+import com.intellectualcrafters.plot.util.PlotQueue;
+import com.intellectualcrafters.plot.util.SetQueue;
+import com.intellectualcrafters.plot.util.SetQueue.ChunkWrapper;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map.Entry;
+import java.util.concurrent.ConcurrentHashMap;
+import org.bukkit.Chunk;
+import org.bukkit.block.Biome;
+import org.bukkit.block.Block;
+
+public class SlowQueue implements PlotQueue<Chunk> {
+
+    private final ConcurrentHashMap<ChunkWrapper, PlotChunk<Chunk>> blocks = new ConcurrentHashMap<>();
+
+    public SlowQueue() {
+        MainUtil.initCache();
+    }
+
+    @Override
+    public boolean setBlock(String world, int x, int y, int z, short id, byte data) {
+        if (y > 255 || y < 0) {
+            return false;
+        }
+        ChunkWrapper wrap = SetQueue.IMP.new ChunkWrapper(world, x >> 4, z >> 4);
+        x = x & 15;
+        z = z & 15;
+        PlotChunk<Chunk> result = this.blocks.get(wrap);
+        if (result == null) {
+            result = getChunk(wrap);
+            result.setBlock(x, y, z, id, data);
+            PlotChunk<Chunk> previous = this.blocks.put(wrap, result);
+            if (previous == null) {
+                return true;
+            }
+            this.blocks.put(wrap, previous);
+            result = previous;
+        }
+        result.setBlock(x, y, z, id, data);
+        return true;
+    }
+
+    @Override
+    public void setChunk(PlotChunk<Chunk> chunk) {
+        this.blocks.put(chunk.getChunkWrapper(), chunk);
+    }
+
+    @Override
+    public PlotChunk<Chunk> next() {
+        if (!PS.get().isMainThread(Thread.currentThread())) {
+            throw new IllegalStateException("Must be called from main thread!");
+        }
+        try {
+            if (this.blocks.isEmpty()) {
+                return null;
+            }
+            Iterator<Entry<ChunkWrapper, PlotChunk<Chunk>>> iterator = this.blocks.entrySet().iterator();
+            PlotChunk<Chunk> toReturn = iterator.next().getValue();
+            if (SetQueue.IMP.isWaiting()) {
+                return null;
+            }
+            iterator.remove();
+            execute(toReturn);
+            fixLighting(toReturn, true);
+            return toReturn;
+        } catch (Throwable e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    @Override
+    public PlotChunk<Chunk> next(ChunkWrapper wrap, boolean fixLighting) {
+        if (!PS.get().isMainThread(Thread.currentThread())) {
+            throw new IllegalStateException("Must be called from main thread!");
+        }
+        try {
+            if (this.blocks.isEmpty()) {
+                return null;
+            }
+            PlotChunk<Chunk> toReturn = this.blocks.remove(wrap);
+            if (toReturn == null) {
+                return null;
+            }
+            execute(toReturn);
+            fixLighting(toReturn, fixLighting);
+            return toReturn;
+        } catch (Throwable e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    @Override
+    public void clear() {
+        this.blocks.clear();
+    }
+
+    /**
+     * This should be overridden by any specialized queues.
+     * @param plotChunk
+     */
+    public void execute(PlotChunk<Chunk> plotChunk) {
+        SlowChunk sc = (SlowChunk) plotChunk;
+        Chunk chunk = plotChunk.getChunk();
+        chunk.load(true);
+        for (int i = 0; i < sc.result.length; i++) {
+            PlotBlock[] result2 = sc.result[i];
+            if (result2 == null) {
+                continue;
+            }
+            for (int j = 0; j < 4096; j++) {
+                int x = MainUtil.x_loc[i][j];
+                int y = MainUtil.y_loc[i][j];
+                int z = MainUtil.z_loc[i][j];
+                Block block = chunk.getBlock(x, y, z);
+                PlotBlock newBlock = result2[j];
+                if (newBlock == null) {
+                    continue;
+                }
+                switch (newBlock.id) {
+                    case -1:
+                        if (block.getData() == newBlock.data) {
+                            continue;
+                        }
+                        block.setData(newBlock.data);
+                        continue;
+                    case 0:
+                    case 2:
+                    case 4:
+                    case 13:
+                    case 14:
+                    case 15:
+                    case 20:
+                    case 21:
+                    case 22:
+                    case 25:
+                    case 30:
+                    case 32:
+                    case 37:
+                    case 39:
+                    case 40:
+                    case 41:
+                    case 42:
+                    case 45:
+                    case 46:
+                    case 47:
+                    case 48:
+                    case 49:
+                    case 51:
+                    case 52:
+                    case 54:
+                    case 55:
+                    case 56:
+                    case 57:
+                    case 58:
+                    case 60:
+                    case 61:
+                    case 62:
+                    case 7:
+                    case 8:
+                    case 9:
+                    case 10:
+                    case 11:
+                    case 73:
+                    case 74:
+                    case 78:
+                    case 79:
+                    case 80:
+                    case 81:
+                    case 82:
+                    case 83:
+                    case 84:
+                    case 85:
+                    case 87:
+                    case 88:
+                    case 101:
+                    case 102:
+                    case 103:
+                    case 110:
+                    case 112:
+                    case 113:
+                    case 117:
+                    case 121:
+                    case 122:
+                    case 123:
+                    case 124:
+                    case 129:
+                    case 133:
+                    case 138:
+                    case 137:
+                    case 140:
+                    case 165:
+                    case 166:
+                    case 169:
+                    case 170:
+                    case 172:
+                    case 173:
+                    case 174:
+                    case 176:
+                    case 177:
+                    case 181:
+                    case 182:
+                    case 188:
+                    case 189:
+                    case 190:
+                    case 191:
+                    case 192:
+                        if (block.getTypeId() == newBlock.id) {
+                            continue;
+                        }
+                        block.setTypeId(newBlock.id, false);
+                        continue;
+                    default:
+                        if (block.getTypeId() == newBlock.id && block.getData() == newBlock.data) {
+                            continue;
+                        }
+                        if (newBlock.data == 0) {
+                            block.setTypeId(newBlock.id, false);
+                        } else {
+                            block.setTypeIdAndData(newBlock.id, newBlock.data, false);
+                        }
+                        continue;
+                }
+            }
+        }
+        int[][] biomes = sc.biomes;
+        Biome[] values = Biome.values();
+        if (biomes != null) {
+            for (int x = 0; x < 16; x++) {
+                int[] array = biomes[x];
+                if (array == null) {
+                    continue;
+                }
+                for (int z = 0; z < 16; z++) {
+                    int biome = array[z];
+                    if (biome == 0) {
+                        continue;
+                    }
+                    chunk.getBlock(x, 0, z).setBiome(values[biome]);
+                }
+            }
+        }
+    }
+
+    /**
+     * This should be overridden by any specialized queues.
+     * @param wrap
+     */
+    @Override
+    public PlotChunk<Chunk> getChunk(ChunkWrapper wrap) {
+        return new SlowChunk(wrap);
+    }
+
+    /**
+     * This should be overridden by any specialized queues.
+     * @param fixAll
+     */
+    @Override
+    public boolean fixLighting(PlotChunk<Chunk> chunk, boolean fixAll) {
+        // Do nothing
+        return true;
+    }
+
+    /**
+     * This should be overridden by any specialized queues.
+     * @param locations
+     */
+    @Override
+    public void sendChunk(String world, Collection<ChunkLoc> locations) {
+        // Do nothing
+    }
+}

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

@@ -1,44 +1,49 @@
 package com.plotsquared.bukkit.uuid;
 
-import java.util.UUID;
-
-import org.bukkit.Bukkit;
-import org.bukkit.OfflinePlayer;
-
 import com.intellectualcrafters.plot.object.OfflinePlotPlayer;
 import com.intellectualcrafters.plot.object.PlotPlayer;
 import com.intellectualcrafters.plot.uuid.UUIDWrapper;
 import com.plotsquared.bukkit.object.BukkitOfflinePlayer;
 import com.plotsquared.bukkit.object.BukkitPlayer;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+
+import java.util.UUID;
 
 public class DefaultUUIDWrapper extends UUIDWrapper {
+
     @Override
-    public UUID getUUID(final PlotPlayer player) {
+    public UUID getUUID(PlotPlayer player) {
         return ((BukkitPlayer) player).player.getUniqueId();
     }
 
     @Override
-    public UUID getUUID(final OfflinePlotPlayer player) {
+    public UUID getUUID(OfflinePlotPlayer player) {
         return player.getUUID();
     }
 
     @Override
-    public OfflinePlotPlayer getOfflinePlayer(final UUID uuid) {
+    public OfflinePlotPlayer getOfflinePlayer(UUID uuid) {
         return new BukkitOfflinePlayer(Bukkit.getOfflinePlayer(uuid));
     }
 
     @Override
-    public UUID getUUID(final String name) {
+    public UUID getUUID(String name) {
         return Bukkit.getOfflinePlayer(name).getUniqueId();
     }
 
     @Override
     public OfflinePlotPlayer[] getOfflinePlayers() {
         OfflinePlayer[] ops = Bukkit.getOfflinePlayers();
-        BukkitOfflinePlayer[] toReturn = new BukkitOfflinePlayer[ops.length] ;
+        BukkitOfflinePlayer[] toReturn = new BukkitOfflinePlayer[ops.length];
         for (int i = 0; i < ops.length; i++) {
             toReturn[i] = new BukkitOfflinePlayer(ops[i]);
         }
         return toReturn;
     }
+
+    @Override
+    public OfflinePlotPlayer getOfflinePlayer(String name) {
+        return new BukkitOfflinePlayer(Bukkit.getOfflinePlayer(name));
+    }
 }

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

@@ -1,18 +1,7 @@
 package com.plotsquared.bukkit.uuid;
 
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FilenameFilter;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.UUID;
-
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-
 import com.google.common.collect.HashBiMap;
-import com.google.common.io.Files;
+import com.google.common.io.ByteSource;
 import com.google.common.io.InputSupplier;
 import com.intellectualcrafters.plot.PS;
 import com.intellectualcrafters.plot.config.C;
@@ -22,122 +11,164 @@ import com.intellectualcrafters.plot.object.OfflinePlotPlayer;
 import com.intellectualcrafters.plot.object.RunnableVal;
 import com.intellectualcrafters.plot.object.StringWrapper;
 import com.intellectualcrafters.plot.util.ExpireManager;
-import com.intellectualcrafters.plot.util.NbtFactory;
+import com.intellectualcrafters.plot.util.StringMan;
 import com.intellectualcrafters.plot.util.TaskManager;
 import com.intellectualcrafters.plot.util.UUIDHandler;
 import com.intellectualcrafters.plot.util.UUIDHandlerImplementation;
 import com.intellectualcrafters.plot.uuid.UUIDWrapper;
+import com.plotsquared.bukkit.util.NbtFactory;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FilenameFilter;
+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) {
-        if (!super.startCaching(whenDone)) {
-            return false;
-        }
-        return cache(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.size() == 0) {
+        if (worlds.isEmpty()) {
             world = "world";
-        }
-        else {
+        } else {
             world = worlds.get(0).getName();
         }
         TaskManager.runTaskAsync(new Runnable() {
             @Override
             public void run() {
-                PS.debug(C.PREFIX.s() + "&6Starting player data caching for: " + world);
+                PS.debug(C.PREFIX + "&6Starting player data caching for: " + world);
+                File uuidFile = new File(PS.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();
+                    }
+                }
                 if (Settings.TWIN_MODE_UUID) {
-                    final HashBiMap<StringWrapper, UUID> toAdd = HashBiMap.create(new HashMap<StringWrapper, UUID>());
+                    HashBiMap<StringWrapper, UUID> toAdd = HashBiMap.create(new HashMap<StringWrapper, UUID>());
                     toAdd.put(new StringWrapper("*"), DBFunc.everyone);
                     HashSet<UUID> all = UUIDHandler.getAllUUIDS();
                     PS.debug("&aFast mode UUID caching enabled!");
-                    final File playerdataFolder = new File(container, world + File.separator + "playerdata");
-                    String[] dat = playerdataFolder.list(new FilenameFilter() {
+                    File playerDataFolder = new File(container, world + File.separator + "playerdata");
+                    String[] dat = playerDataFolder.list(new FilenameFilter() {
                         @Override
-                        public boolean accept(final File f, final String s) {
+                        public boolean accept(File f, String s) {
                             return s.endsWith(".dat");
                         }
                     });
-                    boolean check = all.size() == 0;
+                    boolean check = all.isEmpty();
                     if (dat != null) {
-                        for (final String current : dat) {
-                            final String s = current.replaceAll(".dat$", "");
+                        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 + File.separator + current);
-                                    InputSupplier<FileInputStream> is = Files.newInputStreamSupplier(file);
+                                    File file = new File(playerDataFolder + File.separator + current);
+                                    InputSupplier<FileInputStream> is = com.google.common.io.Files.newInputStreamSupplier(file);
                                     NbtFactory.NbtCompound compound = NbtFactory.fromStream(is, NbtFactory.StreamOptions.GZIP_COMPRESSION);
                                     NbtFactory.NbtCompound bukkit = (NbtFactory.NbtCompound) compound.get("bukkit");
                                     String name = (String) bukkit.get("lastKnownName");
                                     long last = (long) bukkit.get("lastPlayed");
-                                    ExpireManager.dates.put(uuid, last);
+                                    if (ExpireManager.IMP != null) {
+                                        ExpireManager.IMP.storeDate(uuid, last);
+                                    }
                                     toAdd.put(new StringWrapper(name), uuid);
                                 }
-                            } catch (final Exception e) {
+                            } catch (Exception e) {
                                 e.printStackTrace();
-                                PS.debug(C.PREFIX.s() + "Invalid playerdata: " + current);
+                                PS.debug(C.PREFIX + "Invalid playerdata: " + current);
                             }
                         }
                     }
                     add(toAdd);
-                    if (all.size() == 0) {
-                        if (whenDone != null) whenDone.run();
+                    if (all.isEmpty()) {
+                        if (whenDone != null) {
+                            whenDone.run();
+                        }
                         return;
-                    }
-                    else {
+                    } else {
                         PS.debug("Failed to cache: " + all.size() + " uuids - slowly processing all files");
                     }
                 }
-                final HashBiMap<StringWrapper, UUID> toAdd = HashBiMap.create(new HashMap<StringWrapper, UUID>());
+                HashBiMap<StringWrapper, UUID> toAdd = HashBiMap.create(new HashMap<StringWrapper, UUID>());
                 toAdd.put(new StringWrapper("*"), DBFunc.everyone);
-                final HashSet<String> worlds = new HashSet<>();
+                HashSet<String> worlds = new HashSet<>();
                 worlds.add(world);
                 worlds.add("world");
-                final HashSet<UUID> uuids = new HashSet<>();
-                final HashSet<String> names = new HashSet<>();
-                File playerdataFolder = null;
-                for (final String worldname : worlds) {
+                HashSet<UUID> uuids = new HashSet<>();
+                HashSet<String> names = new HashSet<>();
+                File playerDataFolder = null;
+                for (String worldName : worlds) {
                     // Getting UUIDs
-                    playerdataFolder = new File(container, worldname + File.separator + "playerdata");
-                    String[] dat = playerdataFolder.list(new FilenameFilter() {
+                    playerDataFolder = new File(container, worldName + File.separator + "playerdata");
+                    String[] dat = playerDataFolder.list(new FilenameFilter() {
                         @Override
-                        public boolean accept(final File f, final String s) {
+                        public boolean accept(File f, String s) {
                             return s.endsWith(".dat");
                         }
                     });
-                    if (dat != null && dat.length != 0) {
-                        for (final String current : dat) {
-                            final String s = current.replaceAll(".dat$", "");
+                    if ((dat != null) && (dat.length != 0)) {
+                        for (String current : dat) {
+                            String s = current.replaceAll(".dat$", "");
                             try {
-                                final UUID uuid = UUID.fromString(s);
+                                UUID uuid = UUID.fromString(s);
                                 uuids.add(uuid);
-                            } catch (final Exception e) {
-                                PS.debug(C.PREFIX.s() + "Invalid playerdata: " + current);
+                            } catch (Exception e) {
+                                PS.debug(C.PREFIX + "Invalid PlayerData: " + current);
                             }
                         }
                         break;
                     }
                     // Getting names
-                    final File playersFolder = new File(worldname + File.separator + "players");
+                    File playersFolder = new File(worldName + File.separator + "players");
                     dat = playersFolder.list(new FilenameFilter() {
                         @Override
-                        public boolean accept(final File f, final String s) {
+                        public boolean accept(File f, String s) {
                             return s.endsWith(".dat");
                         }
                     });
-                    if (dat != null && dat.length != 0) {
-                        for (final String current : dat) {
+                    if ((dat != null) && (dat.length != 0)) {
+                        for (String current : dat) {
                             names.add(current.replaceAll(".dat$", ""));
                         }
                         break;
@@ -145,47 +176,56 @@ public class FileUUIDHandler extends UUIDHandlerImplementation {
                 }
                 for (UUID uuid : uuids) {
                     try {
-                        File file = new File(playerdataFolder + File.separator + uuid.toString() + ".dat");
-                        InputSupplier<FileInputStream> is = Files.newInputStreamSupplier(file);
+                        File file = new File(playerDataFolder + File.separator + uuid.toString() + ".dat");
+                        if (!file.exists()) {
+                            continue;
+                        }
+                        ByteSource is = com.google.common.io.Files.asByteSource(file);
                         NbtFactory.NbtCompound compound = NbtFactory.fromStream(is, NbtFactory.StreamOptions.GZIP_COMPRESSION);
                         NbtFactory.NbtCompound bukkit = (NbtFactory.NbtCompound) compound.get("bukkit");
                         String name = (String) bukkit.get("lastKnownName");
                         long last = (long) bukkit.get("lastPlayed");
                         if (Settings.OFFLINE_MODE) {
                             if (Settings.UUID_LOWERCASE && !name.toLowerCase().equals(name)) {
-                                uuid = uuidWrapper.getUUID(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);
                             }
                         }
-                        ExpireManager.dates.put(uuid, last);
+                        if (ExpireManager.IMP != null) {
+                            ExpireManager.IMP.storeDate(uuid, last);
+                        }
                         toAdd.put(new StringWrapper(name), uuid);
-                    } catch (final Throwable e) {
-                        PS.debug(C.PREFIX.s() + "&6Invalid playerdata: " + uuid.toString() + ".dat");
+                    } catch (Throwable e) {
+                        PS.debug(C.PREFIX + "&6Invalid PlayerData: " + uuid.toString() + ".dat");
                     }
                 }
-                for (final String name : names) {
-                    final UUID uuid = uuidWrapper.getUUID(name);
-                    final StringWrapper nameWrap = new StringWrapper(name);
+                for (String name : names) {
+                    UUID uuid = FileUUIDHandler.this.uuidWrapper.getUUID(name);
+                    StringWrapper nameWrap = new StringWrapper(name);
                     toAdd.put(nameWrap, uuid);
                 }
 
-                if (getUUIDMap().size() == 0) {
-                    for (OfflinePlotPlayer op : uuidWrapper.getOfflinePlayers()) {
+                if (getUUIDMap().isEmpty()) {
+                    for (OfflinePlotPlayer op : FileUUIDHandler.this.uuidWrapper.getOfflinePlayers()) {
                         long last = op.getLastPlayed();
                         if (last != 0) {
                             String name = op.getName();
                             StringWrapper wrap = new StringWrapper(name);
-                            UUID uuid = uuidWrapper.getUUID(op);
+                            UUID uuid = FileUUIDHandler.this.uuidWrapper.getUUID(op);
                             toAdd.put(wrap, uuid);
-                            ExpireManager.dates.put(uuid, last);
+                            if (ExpireManager.IMP != null) {
+                                ExpireManager.IMP.storeDate(uuid, last);
+                            }
                         }
                     }
                 }
                 add(toAdd);
-                if (whenDone != null) whenDone.run();
+                if (whenDone != null) {
+                    whenDone.run();
+                }
             }
         });
         return true;
@@ -196,7 +236,7 @@ public class FileUUIDHandler extends UUIDHandlerImplementation {
         TaskManager.runTaskAsync(new Runnable() {
             @Override
             public void run() {
-                ifFetch.value = uuidWrapper.getUUID(name);
+                ifFetch.value = FileUUIDHandler.this.uuidWrapper.getUUID(name);
                 TaskManager.runTask(ifFetch);
             }
         });

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

@@ -0,0 +1,32 @@
+package com.plotsquared.bukkit.uuid;
+
+import com.google.common.base.Charsets;
+import com.intellectualcrafters.plot.object.OfflinePlotPlayer;
+import com.intellectualcrafters.plot.object.PlotPlayer;
+import org.bukkit.OfflinePlayer;
+
+import java.util.UUID;
+
+public class LowerOfflineUUIDWrapper extends OfflineUUIDWrapper {
+
+    @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/plotsquared/bukkit/uuid/OfflineUUIDWrapper.java

@@ -1,14 +1,5 @@
 package com.plotsquared.bukkit.uuid;
 
-import java.lang.reflect.Method;
-import java.util.Collection;
-import java.util.UUID;
-
-import org.bukkit.Bukkit;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.Server;
-import org.bukkit.entity.Player;
-
 import com.google.common.base.Charsets;
 import com.google.common.collect.BiMap;
 import com.intellectualcrafters.plot.PS;
@@ -18,51 +9,58 @@ import com.intellectualcrafters.plot.object.StringWrapper;
 import com.intellectualcrafters.plot.util.UUIDHandler;
 import com.intellectualcrafters.plot.uuid.UUIDWrapper;
 import com.plotsquared.bukkit.object.BukkitOfflinePlayer;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.UUID;
 
 public class OfflineUUIDWrapper extends UUIDWrapper {
-    private Method getOnline = null;
+
     private final Object[] arg = new Object[0];
+    private Method getOnline = null;
 
     public OfflineUUIDWrapper() {
         try {
-            this.getOnline = Server.class.getMethod("getOnlinePlayers", new Class[0]);
-        } catch (final NoSuchMethodException e) {
-            e.printStackTrace();
-        } catch (final SecurityException e) {
+            this.getOnline = Server.class.getMethod("getOnlinePlayers");
+        } catch (NoSuchMethodException | SecurityException e) {
             e.printStackTrace();
         }
     }
 
     @Override
-    public UUID getUUID(final PlotPlayer player) {
+    public UUID getUUID(PlotPlayer player) {
         return UUID.nameUUIDFromBytes(("OfflinePlayer:" + player.getName()).getBytes(Charsets.UTF_8));
     }
 
     @Override
-    public UUID getUUID(final OfflinePlotPlayer player) {
+    public UUID getUUID(OfflinePlotPlayer player) {
         return UUID.nameUUIDFromBytes(("OfflinePlayer:" + player.getName()).getBytes(Charsets.UTF_8));
     }
 
-    public UUID getUUID(final OfflinePlayer player) {
+    public UUID getUUID(OfflinePlayer player) {
         return UUID.nameUUIDFromBytes(("OfflinePlayer:" + player.getName()).getBytes(Charsets.UTF_8));
     }
 
     @Override
-    public OfflinePlotPlayer getOfflinePlayer(final UUID uuid) {
-        final BiMap<UUID, StringWrapper> map = UUIDHandler.getUuidMap().inverse();
+    public OfflinePlotPlayer getOfflinePlayer(UUID uuid) {
+        BiMap<UUID, StringWrapper> map = UUIDHandler.getUuidMap().inverse();
         String name;
         try {
             name = map.get(uuid).value;
-        } catch (final NullPointerException e) {
+        } catch (NullPointerException e) {
             name = null;
         }
         if (name != null) {
-            final OfflinePlayer op = Bukkit.getOfflinePlayer(name);
+            OfflinePlayer op = Bukkit.getOfflinePlayer(name);
             if (op.hasPlayedBefore()) {
                 return new BukkitOfflinePlayer(op);
             }
         }
-        for (final OfflinePlayer player : Bukkit.getOfflinePlayers()) {
+        for (OfflinePlayer player : Bukkit.getOfflinePlayers()) {
             if (getUUID(player).equals(uuid)) {
                 return new BukkitOfflinePlayer(player);
             }
@@ -72,36 +70,42 @@ public class OfflineUUIDWrapper extends UUIDWrapper {
 
     public Player[] getOnlinePlayers() {
         if (this.getOnline == null) {
-            return Bukkit.getOnlinePlayers().toArray(new Player[0]);
+            Collection<? extends Player> onlinePlayers = Bukkit.getOnlinePlayers();
+            return onlinePlayers.toArray(new Player[onlinePlayers.size()]);
         }
         try {
-            final Object players = this.getOnline.invoke(Bukkit.getServer(), this.arg);
+            Object players = this.getOnline.invoke(Bukkit.getServer(), this.arg);
             if (players instanceof Player[]) {
                 return (Player[]) players;
             } else {
-                @SuppressWarnings("unchecked")
-                final Collection<? extends Player> p = (Collection<? extends Player>) players;
-                return p.toArray(new Player[0]);
+                @SuppressWarnings("unchecked") Collection<? extends Player> p = (Collection<? extends Player>) players;
+                return p.toArray(new Player[p.size()]);
             }
-        } catch (final Exception e) {
+        } catch (Exception e) {
             PS.debug("Failed to resolve online players");
             this.getOnline = null;
-            return Bukkit.getOnlinePlayers().toArray(new Player[0]);
+            Collection<? extends Player> onlinePlayers = Bukkit.getOnlinePlayers();
+            return onlinePlayers.toArray(new Player[onlinePlayers.size()]);
         }
     }
 
     @Override
-    public UUID getUUID(final String name) {
+    public UUID getUUID(String name) {
         return UUID.nameUUIDFromBytes(("OfflinePlayer:" + name).getBytes(Charsets.UTF_8));
     }
-    
+
     @Override
     public OfflinePlotPlayer[] getOfflinePlayers() {
         OfflinePlayer[] ops = Bukkit.getOfflinePlayers();
-        BukkitOfflinePlayer[] toReturn = new BukkitOfflinePlayer[ops.length] ;
+        BukkitOfflinePlayer[] toReturn = new BukkitOfflinePlayer[ops.length];
         for (int i = 0; i < ops.length; i++) {
             toReturn[i] = new BukkitOfflinePlayer(ops[i]);
         }
         return toReturn;
     }
+
+    @Override
+    public OfflinePlotPlayer getOfflinePlayer(String name) {
+        return new BukkitOfflinePlayer(Bukkit.getOfflinePlayer(name));
+    }
 }

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

@@ -0,0 +1,248 @@
+package com.plotsquared.bukkit.uuid;
+
+import com.google.common.collect.HashBiMap;
+import com.intellectualcrafters.plot.PS;
+import com.intellectualcrafters.plot.config.C;
+import com.intellectualcrafters.plot.config.Settings;
+import com.intellectualcrafters.plot.database.DBFunc;
+import com.intellectualcrafters.plot.database.SQLite;
+import com.intellectualcrafters.plot.object.RunnableVal;
+import com.intellectualcrafters.plot.object.StringWrapper;
+import com.intellectualcrafters.plot.util.TaskManager;
+import com.intellectualcrafters.plot.util.UUIDHandler;
+import com.intellectualcrafters.plot.util.UUIDHandlerImplementation;
+import com.intellectualcrafters.plot.uuid.UUIDWrapper;
+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.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;
+
+public class SQLUUIDHandler extends UUIDHandlerImplementation {
+
+    final int MAX_REQUESTS = 500;
+    private final String PROFILE_URL = "https://sessionserver.mojang.com/session/minecraft/profile/";
+    private final int INTERVAL = 12000;
+    private final JSONParser jsonParser = new JSONParser();
+    private final SQLite sqlite;
+
+    public SQLUUIDHandler(UUIDWrapper wrapper) {
+        super(wrapper);
+        this.sqlite = new SQLite("./plugins/PlotSquared/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(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    HashBiMap<StringWrapper, UUID> toAdd = HashBiMap.create(new HashMap<StringWrapper, UUID>());
+                    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);
+                    }
+                    statement.close();
+                    add(toAdd);
+                    add(new StringWrapper("*"), DBFunc.everyone);
+
+                    // 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(new Runnable() {
+                        @Override
+                        public void run() {
+                            // 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.OFFLINE_MODE) {
+                                if (whenDone != null) {
+                                    whenDone.run();
+                                }
+                                return;
+                            }
+
+                            TaskManager.runTaskAsync(new Runnable() {
+                                @Override
+                                public void run() {
+                                    try {
+                                        if (toFetch.isEmpty()) {
+                                            if (whenDone != null) {
+                                                whenDone.run();
+                                            }
+                                            return;
+                                        }
+                                        for (int i = 0; i < Math.min(500, toFetch.size()); i++) {
+                                            UUID uuid = toFetch.pop();
+                                            HttpURLConnection connection =
+                                                    (HttpURLConnection) new URL(SQLUUIDHandler.this.PROFILE_URL + uuid.toString().replace("-", ""))
+                                                            .openConnection();
+                                            InputStreamReader reader = new InputStreamReader(connection.getInputStream());
+                                            JSONObject response = (JSONObject) SQLUUIDHandler.this.jsonParser.parse(reader);
+                                            String name = (String) response.get("name");
+                                            if (name != null) {
+                                                add(new StringWrapper(name), uuid);
+                                            }
+                                        }
+                                    } catch (IOException | ParseException e) {
+                                        e.printStackTrace();
+                                    }
+                                    TaskManager.runTaskLaterAsync(this, SQLUUIDHandler.this.INTERVAL);
+                                }
+                            });
+                        }
+                    });
+                } catch (SQLException e) {
+                    throw new SQLUUIDHandlerException("Couldn't select :s", e);
+                }
+            }
+        });
+        return true;
+    }
+
+    @Override
+    public void fetchUUID(final String name, final RunnableVal<UUID> ifFetch) {
+        PS.debug(C.PREFIX + "UUID for '" + name + "' was null. We'll cache this from the Mojang servers!");
+        if (ifFetch == null) {
+            return;
+        }
+        TaskManager.runTaskAsync(new Runnable() {
+            @Override
+            public void run() {
+                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 name = (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);
+        }
+    }
+
+    @Override
+    public boolean add(final StringWrapper name, final UUID uuid) {
+        // Ignoring duplicates
+        if (super.add(name, uuid)) {
+            TaskManager.runTaskAsync(new Runnable() {
+                @Override
+                public void run() {
+                    try (PreparedStatement statement = getConnection().prepareStatement("REPLACE INTO usercache (`uuid`, `username`) VALUES(?, ?)")) {
+                        statement.setString(1, uuid.toString());
+                        statement.setString(2, name.toString());
+                        statement.execute();
+                        PS.debug(C.PREFIX + "&cAdded '&6" + uuid + "&c' - '&6" + name + "&c'");
+                    } catch (SQLException e) {
+                        e.printStackTrace();
+                    }
+                }
+            });
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * This is useful for name changes
+     */
+    @Override
+    public void rename(final UUID uuid, final StringWrapper name) {
+        super.rename(uuid, name);
+        TaskManager.runTaskAsync(new Runnable() {
+            @Override
+            public void run() {
+                try (PreparedStatement statement = getConnection().prepareStatement("UPDATE usercache SET `username`=? WHERE `uuid`=?")) {
+                    statement.setString(1, name.value);
+                    statement.setString(2, uuid.toString());
+                    statement.execute();
+                    PS.debug(C.PREFIX + "Name change for '" + uuid + "' to '" + name.value + "'");
+                } catch (SQLException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    private class SQLUUIDHandlerException extends RuntimeException {
+
+        SQLUUIDHandlerException(String s, Throwable c) {
+            super("SQLUUIDHandler caused an exception: " + s, c);
+        }
+    }
+}

Bukkit/src/main/resources/plugin.yml

@@ -1,6 +1,6 @@
-name: ${project.name}
+name: ${name}
 main: com.plotsquared.bukkit.BukkitMain
-version: ${project.version}
+version: ${version}
 load: STARTUP
 description: >
              Easy, yet powerful Plot World generation and management.
@@ -15,10 +15,6 @@ commands:
     permission: plots.use
     permission-message: "You are lacking the permission node 'plots.use'"
 permissions:
-  plots.admin:
-    children:
-      plots.*: true
-    default: op
   plots.use:
     default: true
   plots.permpack.basicflags:
@@ -26,43 +22,51 @@ permissions:
     children:
       plots.set.flag: true
       plots.flag: true
-      plots.set.flag.titles: true
-      plots.set.flag.greeting: true
-      plots.set.flag.farewell: true
-      plots.set.flag.notify-enter: true
-      plots.set.flag.notify-leave: true
-      plots.set.flag.feed: true
-      plots.set.flag.heal: true
-      plots.set.flag.invincible: true
-      plots.set.flag.instabreak: true
-      plots.set.flag.fly: true
+      plots.flag.add: true
+      plots.flag.remove: true
+      plots.flag.list: true
+      plots.flag.info: true
+      plots.set.flag.titles.*: true
+      plots.set.flag.greeting.*: true
+      plots.set.flag.farewell.*: true
+      plots.set.flag.notify-enter.*: true
+      plots.set.flag.notify-leave.*: true
+      plots.set.flag.feed.*: true
+      plots.set.flag.heal.*: true
+      plots.set.flag.invincible.*: true
+      plots.set.flag.instabreak.*: true
+      plots.set.flag.fly.*: true
       plots.set.flag.gamemode: true
-      plots.set.flag.time: true
-      plots.set.flag.weather: true
-      plots.set.flag.music: true
-      plots.set.flag.disable-physics: true
-      plots.set.flag.pve: true
-      plots.set.flag.pvp: true
-      plots.set.flag.explosion: true
-      plots.set.flag.hostile-interact: true
-      plots.set.flag.hostile-attack: true
-      plots.set.flag.animal-interact: true
-      plots.set.flag.animal-attack: true
-      plots.set.flag.tamed-interact: true
-      plots.set.flag.tamed-attack: true
-      plots.set.flag.misc-interact: true
-      plots.set.flag.hanging-place: true
-      plots.set.flag.hanging-break: true
-      plots.set.flag.vehicle-use: true
-      plots.set.flag.vehicle-place: true
-      plots.set.flag.vehicle-break: true
-      plots.set.flag.player-interact: true
-      plots.set.flag.place: true
-      plots.set.flag.break: true
-      plots.set.flag.use: true
-      plots.set.flag.forcefield: true
-      plots.set.flag.price: true
-      plots.set.flag.no-worldedit: true
+      plots.set.flag.gamemode.creative: true
+      plots.set.flag.gamemode.survival: true
+      plots.set.flag.gamemode.adventure: true
+      plots.set.flag.time.*: true
+      plots.set.flag.weather.*: true
+      plots.set.flag.music.*: true
+      plots.set.flag.disable-physics.*: true
+      plots.set.flag.pve.*: true
+      plots.set.flag.pvp.*: true
+      plots.set.flag.explosion.*: true
+      plots.set.flag.hostile-interact.*: true
+      plots.set.flag.hostile-attack.*: true
+      plots.set.flag.player-interact.*: true
+      plots.set.flag.animal-interact.*: true
+      plots.set.flag.animal-attack.*: true
+      plots.set.flag.tamed-interact.*: true
+      plots.set.flag.tamed-attack.*: true
+      plots.set.flag.misc-interact.*: true
+      plots.set.flag.hanging-place.*: true
+      plots.set.flag.hanging-break.*: true
+      plots.set.flag.vehicle-use.*: true
+      plots.set.flag.vehicle-place.*: true
+      plots.set.flag.vehicle-break.*: true
+      plots.set.flag.player-interact.*: true
+      plots.set.flag.place.*: true
+      plots.set.flag.break.*: true
+      plots.set.flag.use.*: true
+      plots.set.flag.forcefield.*: true
+      plots.set.flag.price.*: true
+      plots.set.flag.no-worldedit.*: true
   plots.permpack.basicinbox:
     default: op
     children:
@@ -81,6 +85,15 @@ permissions:
       plots.inbox.read.owner: true
       plots.comment: true
       plots.inbox: true
+  plots.permpack.wilderness:
+    default: op
+    children:
+      plots.admin.interact.unowned: true
+      plots.admin.destroy.unowned: true
+      plots.admin.build.unowned: true
+      plots.projectile.unowned: true
+      plots.admin.vehicle.break.unowned: true
+      plots.admin.pve.unowned: true
   plots.permpack.basic:
     default: op
     children:
@@ -104,6 +117,10 @@ permissions:
       plots.visit.owned: true
       plots.visit.shared: true
       plots.set.flag: true
+      plots.flag.add: true
+      plots.flag.remove: true
+      plots.flag.list: true
+      plots.flag.info: true
       plots.flag: true
       plots.buy: true
       plots.chat: true
@@ -115,6 +132,7 @@ permissions:
       plots.set.home: true
       plots.merge: true
       plots.merge.other: true
+      plots.merge.4: true
       plots.unlink: true
       plots.denied: true
       plots.add: true
@@ -128,7 +146,10 @@ permissions:
       plots.save: true
       plots.done: true
       plots.continue: true
+      plots.middle: true
   plots.worldedit.bypass:
     default: false
   plots.gamemode.bypass:
-    default: op
+    default: op
+  plots.confirm.bypass:
+    default: false

Core/build.gradle

@@ -0,0 +1,11 @@
+dependencies {
+    testCompile 'junit:junit:4.12'
+    compile 'org.yaml:snakeyaml:1.16'
+    compile 'com.google.code.gson:gson:2.2.4'
+}
+
+sourceCompatibility = 1.7
+targetCompatibility = 1.7
+
+jar.archiveName="PlotSquared-API-${parent.version}.jar"
+jar.destinationDir = file '../target'

Core/src/main/java/com/intellectualcrafters/configuration/Configuration.java

@@ -20,8 +20,8 @@ public interface Configuration extends ConfigurationSection {
      * @param value Value to set the default to.
      * @throws IllegalArgumentException Thrown if path is null.
      */
-    public void addDefault(String path, Object value);
-
+    @Override void addDefault(final String path, final Object value);
+    
     /**
      * Sets the default values of the given paths as provided.
      * <p>
@@ -32,8 +32,8 @@ public interface Configuration extends ConfigurationSection {
      * @param defaults A map of Path->Values to add to defaults.
      * @throws IllegalArgumentException Thrown if defaults is null.
      */
-    public void addDefaults(Map<String, Object> defaults);
-
+    void addDefaults(final Map<String, Object> defaults);
+    
     /**
      * Sets the default values of the given paths as provided.
      * <p>
@@ -49,8 +49,8 @@ public interface Configuration extends ConfigurationSection {
      * @param defaults A configuration holding a list of defaults to copy.
      * @throws IllegalArgumentException Thrown if defaults is null or this.
      */
-    public void addDefaults(Configuration defaults);
-
+    void addDefaults(final Configuration defaults);
+    
     /**
      * Sets the source of all default values for this {@link Configuration}.
      * <p>
@@ -60,8 +60,8 @@ public interface Configuration extends ConfigurationSection {
      * @param defaults New source of default values for this configuration.
      * @throws IllegalArgumentException Thrown if defaults is null or this.
      */
-    public void setDefaults(Configuration defaults);
-
+    void setDefaults(final Configuration defaults);
+    
     /**
      * Gets the source {@link Configuration} for this configuration.
      * <p>
@@ -71,8 +71,8 @@ public interface Configuration extends ConfigurationSection {
      *
      * @return Configuration source for default values, or null if none exist.
      */
-    public Configuration getDefaults();
-
+    Configuration getDefaults();
+    
     /**
      * Gets the {@link ConfigurationOptions} for this {@link Configuration}.
      * <p>
@@ -80,5 +80,5 @@ public interface Configuration extends ConfigurationSection {
      *
      * @return Options for this configuration
      */
-    public ConfigurationOptions options();
+    ConfigurationOptions options();
 }

Core/src/main/java/com/intellectualcrafters/configuration/ConfigurationOptions.java

@@ -8,11 +8,11 @@ public class ConfigurationOptions {
     private char pathSeparator = '.';
     private boolean copyDefaults = false;
     private final Configuration configuration;
-
-    protected ConfigurationOptions(Configuration configuration) {
+    
+    protected ConfigurationOptions(final Configuration configuration) {
         this.configuration = configuration;
     }
-
+    
     /**
      * Returns the {@link Configuration} that this object is responsible for.
      *
@@ -21,7 +21,7 @@ public class ConfigurationOptions {
     public Configuration configuration() {
         return configuration;
     }
-
+    
     /**
      * Gets the char that will be used to separate {@link
      * ConfigurationSection}s
@@ -34,7 +34,7 @@ public class ConfigurationOptions {
     public char pathSeparator() {
         return pathSeparator;
     }
-
+    
     /**
      * Sets the char that will be used to separate {@link
      * ConfigurationSection}s
@@ -45,11 +45,11 @@ public class ConfigurationOptions {
      * @param value Path separator
      * @return This object, for chaining
      */
-    public ConfigurationOptions pathSeparator(char value) {
-        this.pathSeparator = value;
+    public ConfigurationOptions pathSeparator(final char value) {
+        pathSeparator = value;
         return this;
     }
-
+    
     /**
      * Checks if the {@link Configuration} should copy values from its default
      * {@link Configuration} directly.
@@ -67,7 +67,7 @@ public class ConfigurationOptions {
     public boolean copyDefaults() {
         return copyDefaults;
     }
-
+    
     /**
      * Sets if the {@link Configuration} should copy values from its default
      * {@link Configuration} directly.
@@ -83,8 +83,8 @@ public class ConfigurationOptions {
      * @param value Whether or not defaults are directly copied
      * @return This object, for chaining
      */
-    public ConfigurationOptions copyDefaults(boolean value) {
-        this.copyDefaults = value;
+    public ConfigurationOptions copyDefaults(final boolean value) {
+        copyDefaults = value;
         return this;
     }
 }

Core/src/main/java/com/intellectualcrafters/configuration/ConfigurationSection.java

@@ -8,6 +8,7 @@ import java.util.Set;
  * Represents a section of a {@link Configuration}
  */
 public interface ConfigurationSection {
+
     /**
      * Gets a set containing all keys in this section.
      * <p>
@@ -22,7 +23,7 @@ public interface ConfigurationSection {
      *     list.
      * @return Set of keys contained within this ConfigurationSection.
      */
-    public Set<String> getKeys(boolean deep);
+    Set<String> getKeys(boolean deep);
 
     /**
      * Gets a Map containing all keys and their values for this section.
@@ -38,7 +39,7 @@ public interface ConfigurationSection {
      *     list.
      * @return Map of keys and values of this section.
      */
-    public Map<String, Object> getValues(boolean deep);
+    Map<String, Object> getValues(boolean deep);
 
     /**
      * Checks if this {@link ConfigurationSection} contains the given path.
@@ -51,7 +52,7 @@ public interface ConfigurationSection {
      *     default or being set.
      * @throws IllegalArgumentException Thrown when path is null.
      */
-    public boolean contains(String path);
+    boolean contains(String path);
 
     /**
      * Checks if this {@link ConfigurationSection} has a value set for the
@@ -65,7 +66,7 @@ public interface ConfigurationSection {
      *     having a default.
      * @throws IllegalArgumentException Thrown when path is null.
      */
-    public boolean isSet(String path);
+    boolean isSet(String path);
 
     /**
      * Gets the path of this {@link ConfigurationSection} from its root {@link
@@ -82,7 +83,7 @@ public interface ConfigurationSection {
      *
      * @return Path of this section relative to its root
      */
-    public String getCurrentPath();
+    String getCurrentPath();
 
     /**
      * Gets the name of this individual {@link ConfigurationSection}, in the
@@ -93,7 +94,7 @@ public interface ConfigurationSection {
      *
      * @return Name of this section
      */
-    public String getName();
+    String getName();
 
     /**
      * Gets the root {@link Configuration} that contains this {@link
@@ -107,7 +108,7 @@ public interface ConfigurationSection {
      *
      * @return Root configuration containing this section.
      */
-    public Configuration getRoot();
+    Configuration getRoot();
 
     /**
      * Gets the parent {@link ConfigurationSection} that directly contains
@@ -120,7 +121,7 @@ public interface ConfigurationSection {
      *
      * @return Parent section containing this section.
      */
-    public ConfigurationSection getParent();
+    ConfigurationSection getParent();
 
     /**
      * Gets the requested Object by path.
@@ -132,7 +133,7 @@ public interface ConfigurationSection {
      * @param path Path of the Object to get.
      * @return Requested Object.
      */
-    public Object get(String path);
+    Object get(String path);
 
     /**
      * Gets the requested Object by path, returning a default value if not
@@ -146,7 +147,7 @@ public interface ConfigurationSection {
      * @param def The default value to return if the path is not found.
      * @return Requested Object.
      */
-    public Object get(String path, Object def);
+    Object get(String path, Object def);
 
     /**
      * Sets the specified path to the given value.
@@ -155,14 +156,14 @@ public interface ConfigurationSection {
      * replaced, regardless of what the new value is.
      * <p>
      * Some implementations may have limitations on what you may store. See
-     * their individual javadocs for details. No implementations should allow
+     * their individual javadoc for details. No implementations should allow
      * you to store {@link Configuration}s or {@link ConfigurationSection}s,
-     * please use {@link #createSection(java.lang.String)} for that.
+     * please use {@link #createSection(String)} for that.
      *
      * @param path Path of the object to set.
      * @param value New value to set the path to.
      */
-    public void set(String path, Object value);
+    void set(String path, Object value);
 
     /**
      * Creates an empty {@link ConfigurationSection} at the specified path.
@@ -174,7 +175,7 @@ public interface ConfigurationSection {
      * @param path Path to create the section at.
      * @return Newly created section
      */
-    public ConfigurationSection createSection(String path);
+    ConfigurationSection createSection(String path);
 
     /**
      * Creates a {@link ConfigurationSection} at the specified path, with
@@ -188,9 +189,10 @@ public interface ConfigurationSection {
      * @param map The values to used.
      * @return Newly created section
      */
-    public ConfigurationSection createSection(String path, Map<?, ?> map);
+    ConfigurationSection createSection(String path, Map<?, ?> map);
 
     // Primitives
+
     /**
      * Gets the requested String by path.
      * <p>
@@ -201,7 +203,7 @@ public interface ConfigurationSection {
      * @param path Path of the String to get.
      * @return Requested String.
      */
-    public String getString(String path);
+    String getString(String path);
 
     /**
      * Gets the requested String by path, returning a default value if not
@@ -216,59 +218,59 @@ public interface ConfigurationSection {
      *     not a String.
      * @return Requested String.
      */
-    public String getString(String path, String def);
+    String getString(String path, String def);
 
     /**
      * Checks if the specified path is a String.
-     * <p>
-     * If the path exists but is not a String, this will return false. If the
+     *
+     * <p> If the path exists but is not a String, this will return false. If the
      * path does not exist, this will return false. If the path does not exist
      * but a default value has been specified, this will check if that default
-     * value is a String and return appropriately.
+     * value is a String and return appropriately.</p>
      *
      * @param path Path of the String to check.
      * @return Whether or not the specified path is a String.
      */
-    public boolean isString(String path);
+    boolean isString(String path);
 
     /**
      * Gets the requested int by path.
-     * <p>
-     * If the int does not exist but a default value has been specified, this
+     *
+     * <p>If the int does not exist but a default value has been specified, this
      * will return the default value. If the int does not exist and no default
-     * value was specified, this will return 0.
+     * value was specified, this will return 0.</p>
      *
      * @param path Path of the int to get.
      * @return Requested int.
      */
-    public int getInt(String path);
+    int getInt(String path);
 
     /**
      * Gets the requested int by path, returning a default value if not found.
-     * <p>
-     * If the int does not exist then the specified default value will
+     *
+     * <p>If the int does not exist then the specified default value will
      * returned regardless of if a default has been identified in the root
-     * {@link Configuration}.
+     * {@link Configuration}.</p>
      *
      * @param path Path of the int to get.
      * @param def The default value to return if the path is not found or is
      *     not an int.
      * @return Requested int.
      */
-    public int getInt(String path, int def);
+    int getInt(String path, int def);
 
     /**
      * Checks if the specified path is an int.
-     * <p>
-     * If the path exists but is not a int, this will return false. If the
+     *
+     * <p>If the path exists but is not a int, this will return false. If the
      * path does not exist, this will return false. If the path does not exist
      * but a default value has been specified, this will check if that default
-     * value is a int and return appropriately.
+     * value is a int and return appropriately.</p>
      *
      * @param path Path of the int to check.
      * @return Whether or not the specified path is an int.
      */
-    public boolean isInt(String path);
+    boolean isInt(String path);
 
     /**
      * Gets the requested boolean by path.
@@ -280,7 +282,7 @@ public interface ConfigurationSection {
      * @param path Path of the boolean to get.
      * @return Requested boolean.
      */
-    public boolean getBoolean(String path);
+    boolean getBoolean(String path);
 
     /**
      * Gets the requested boolean by path, returning a default value if not
@@ -295,7 +297,7 @@ public interface ConfigurationSection {
      *     not a boolean.
      * @return Requested boolean.
      */
-    public boolean getBoolean(String path, boolean def);
+    boolean getBoolean(String path, boolean def);
 
     /**
      * Checks if the specified path is a boolean.
@@ -308,7 +310,7 @@ public interface ConfigurationSection {
      * @param path Path of the boolean to check.
      * @return Whether or not the specified path is a boolean.
      */
-    public boolean isBoolean(String path);
+    boolean isBoolean(String path);
 
     /**
      * Gets the requested double by path.
@@ -320,7 +322,7 @@ public interface ConfigurationSection {
      * @param path Path of the double to get.
      * @return Requested double.
      */
-    public double getDouble(String path);
+    double getDouble(String path);
 
     /**
      * Gets the requested double by path, returning a default value if not
@@ -335,7 +337,7 @@ public interface ConfigurationSection {
      *     not a double.
      * @return Requested double.
      */
-    public double getDouble(String path, double def);
+    double getDouble(String path, double def);
 
     /**
      * Checks if the specified path is a double.
@@ -348,7 +350,7 @@ public interface ConfigurationSection {
      * @param path Path of the double to check.
      * @return Whether or not the specified path is a double.
      */
-    public boolean isDouble(String path);
+    boolean isDouble(String path);
 
     /**
      * Gets the requested long by path.
@@ -360,7 +362,7 @@ public interface ConfigurationSection {
      * @param path Path of the long to get.
      * @return Requested long.
      */
-    public long getLong(String path);
+    long getLong(String path);
 
     /**
      * Gets the requested long by path, returning a default value if not
@@ -375,7 +377,7 @@ public interface ConfigurationSection {
      *     not a long.
      * @return Requested long.
      */
-    public long getLong(String path, long def);
+    long getLong(String path, long def);
 
     /**
      * Checks if the specified path is a long.
@@ -388,9 +390,10 @@ public interface ConfigurationSection {
      * @param path Path of the long to check.
      * @return Whether or not the specified path is a long.
      */
-    public boolean isLong(String path);
+    boolean isLong(String path);
 
     // Java
+
     /**
      * Gets the requested List by path.
      * <p>
@@ -401,7 +404,7 @@ public interface ConfigurationSection {
      * @param path Path of the List to get.
      * @return Requested List.
      */
-    public List<?> getList(String path);
+    List<?> getList(String path);
 
     /**
      * Gets the requested List by path, returning a default value if not
@@ -416,7 +419,7 @@ public interface ConfigurationSection {
      *     not a List.
      * @return Requested List.
      */
-    public List<?> getList(String path, List<?> def);
+    List<?> getList(String path, List<?> def);
 
     /**
      * Checks if the specified path is a List.
@@ -429,7 +432,7 @@ public interface ConfigurationSection {
      * @param path Path of the List to check.
      * @return Whether or not the specified path is a List.
      */
-    public boolean isList(String path);
+    boolean isList(String path);
 
     /**
      * Gets the requested List of String by path.
@@ -444,7 +447,7 @@ public interface ConfigurationSection {
      * @param path Path of the List to get.
      * @return Requested List of String.
      */
-    public List<String> getStringList(String path);
+    List<String> getStringList(String path);
 
     /**
      * Gets the requested List of Integer by path.
@@ -459,7 +462,7 @@ public interface ConfigurationSection {
      * @param path Path of the List to get.
      * @return Requested List of Integer.
      */
-    public List<Integer> getIntegerList(String path);
+    List<Integer> getIntegerList(String path);
 
     /**
      * Gets the requested List of Boolean by path.
@@ -474,7 +477,7 @@ public interface ConfigurationSection {
      * @param path Path of the List to get.
      * @return Requested List of Boolean.
      */
-    public List<Boolean> getBooleanList(String path);
+    List<Boolean> getBooleanList(String path);
 
     /**
      * Gets the requested List of Double by path.
@@ -489,7 +492,7 @@ public interface ConfigurationSection {
      * @param path Path of the List to get.
      * @return Requested List of Double.
      */
-    public List<Double> getDoubleList(String path);
+    List<Double> getDoubleList(String path);
 
     /**
      * Gets the requested List of Float by path.
@@ -504,7 +507,7 @@ public interface ConfigurationSection {
      * @param path Path of the List to get.
      * @return Requested List of Float.
      */
-    public List<Float> getFloatList(String path);
+    List<Float> getFloatList(String path);
 
     /**
      * Gets the requested List of Long by path.
@@ -519,7 +522,7 @@ public interface ConfigurationSection {
      * @param path Path of the List to get.
      * @return Requested List of Long.
      */
-    public List<Long> getLongList(String path);
+    List<Long> getLongList(String path);
 
     /**
      * Gets the requested List of Byte by path.
@@ -534,7 +537,7 @@ public interface ConfigurationSection {
      * @param path Path of the List to get.
      * @return Requested List of Byte.
      */
-    public List<Byte> getByteList(String path);
+    List<Byte> getByteList(String path);
 
     /**
      * Gets the requested List of Character by path.
@@ -549,7 +552,7 @@ public interface ConfigurationSection {
      * @param path Path of the List to get.
      * @return Requested List of Character.
      */
-    public List<Character> getCharacterList(String path);
+    List<Character> getCharacterList(String path);
 
     /**
      * Gets the requested List of Short by path.
@@ -564,7 +567,7 @@ public interface ConfigurationSection {
      * @param path Path of the List to get.
      * @return Requested List of Short.
      */
-    public List<Short> getShortList(String path);
+    List<Short> getShortList(String path);
 
     /**
      * Gets the requested List of Maps by path.
@@ -579,7 +582,7 @@ public interface ConfigurationSection {
      * @param path Path of the List to get.
      * @return Requested List of Maps.
      */
-    public List<Map<?, ?>> getMapList(String path);
+    List<Map<?, ?>> getMapList(String path);
 
     /**
      * Gets the requested ConfigurationSection by path.
@@ -592,7 +595,7 @@ public interface ConfigurationSection {
      * @param path Path of the ConfigurationSection to get.
      * @return Requested ConfigurationSection.
      */
-    public ConfigurationSection getConfigurationSection(String path);
+    ConfigurationSection getConfigurationSection(String path);
 
     /**
      * Checks if the specified path is a ConfigurationSection.
@@ -606,7 +609,7 @@ public interface ConfigurationSection {
      * @param path Path of the ConfigurationSection to check.
      * @return Whether or not the specified path is a ConfigurationSection.
      */
-    public boolean isConfigurationSection(String path);
+    boolean isConfigurationSection(String path);
 
     /**
      * Gets the equivalent {@link ConfigurationSection} from the default
@@ -618,7 +621,7 @@ public interface ConfigurationSection {
      *
      * @return Equivalent section in root configuration
      */
-    public ConfigurationSection getDefaultSection();
+    ConfigurationSection getDefaultSection();
 
     /**
      * Sets the default value in the root at the given path as provided.
@@ -638,5 +641,5 @@ public interface ConfigurationSection {
      * @param value Value to set the default to.
      * @throws IllegalArgumentException Thrown if path is null.
      */
-    public void addDefault(String path, Object value);
+    void addDefault(String path, Object value);
 }

Core/src/main/java/com/intellectualcrafters/configuration/InvalidConfigurationException.java

@@ -5,33 +5,33 @@ package com.intellectualcrafters.configuration;
  */
 @SuppressWarnings("serial")
 public class InvalidConfigurationException extends Exception {
-
+    
     /**
      * Creates a new instance of InvalidConfigurationException without a
      * message or cause.
      */
     public InvalidConfigurationException() {}
-
+    
     /**
      * Constructs an instance of InvalidConfigurationException with the
      * specified message.
      *
      * @param msg The details of the exception.
      */
-    public InvalidConfigurationException(String msg) {
+    public InvalidConfigurationException(final String msg) {
         super(msg);
     }
-
+    
     /**
      * Constructs an instance of InvalidConfigurationException with the
      * specified cause.
      *
      * @param cause The cause of the exception.
      */
-    public InvalidConfigurationException(Throwable cause) {
+    public InvalidConfigurationException(final Throwable cause) {
         super(cause);
     }
-
+    
     /**
      * Constructs an instance of InvalidConfigurationException with the
      * specified message and cause.
@@ -39,7 +39,7 @@ public class InvalidConfigurationException extends Exception {
      * @param cause The cause of the exception.
      * @param msg The details of the exception.
      */
-    public InvalidConfigurationException(String msg, Throwable cause) {
+    public InvalidConfigurationException(final String msg, final Throwable cause) {
         super(msg, cause);
     }
 }