*

Fix #1196

.github/ISSUE_TEMPLATE.md

@@ -1,12 +1,12 @@
-# Bug report template (clear for feature request)
+# 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 X inside of brackets):
-- [ ] Include `/plot debugpaste`
-- [ ] Made sure there aren't duplicates of this report [(Use Search)](https://github.com/IntellectualSites/PlotSquared/issues)
-- [ ] Made sure you're using an updated version of PlotSquared
-- [ ] Made sure the bug/error isn't caused by any other plugin
+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?utf8=%E2%9C%93&q=is%3Aissue)
+- [] Made sure you're using an updated version of PlotSquared
+- [] Made sure the bug/error isn't caused by any other plugin

Bukkit/build.gradle

@@ -1,7 +1,8 @@
 dependencies {
     compile project(':Core')
-    compile 'org.bukkit:bukkit:1.9-R0.1-SNAPSHOT'
-    compile 'net.milkbowl.vault:VaultAPI:1.5'
+    compile 'org.bukkit:bukkit:1.10-R0.1-SNAPSHOT'
+    compile 'org.mcstats.bukkit:metrics:R7'
+    compile 'net.milkbowl.vault:VaultAPI:1.6'
 }
 
 sourceCompatibility = 1.7
@@ -23,7 +24,9 @@ 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'
 }

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

@@ -1,33 +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.intellectualcrafters.plot.api;
 
 import com.intellectualcrafters.configuration.file.YamlConfiguration;
 import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.commands.MainCommand;
 import com.intellectualcrafters.plot.commands.SubCommand;
 import com.intellectualcrafters.plot.config.C;
-import com.intellectualcrafters.plot.flag.AbstractFlag;
+import com.intellectualcrafters.plot.flag.Flag;
 import com.intellectualcrafters.plot.flag.FlagManager;
+import com.intellectualcrafters.plot.flag.Flags;
 import com.intellectualcrafters.plot.object.Plot;
 import com.intellectualcrafters.plot.object.PlotArea;
 import com.intellectualcrafters.plot.object.PlotId;
@@ -35,63 +14,52 @@ 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.Permissions;
 import com.intellectualcrafters.plot.util.SchematicHandler;
-import com.intellectualcrafters.plot.util.SetQueue;
 import com.intellectualcrafters.plot.util.UUIDHandler;
+import com.intellectualcrafters.plot.util.block.GlobalBlockQueue;
 import com.intellectualcrafters.plot.uuid.UUIDWrapper;
 import com.plotsquared.bukkit.util.BukkitUtil;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
 import org.bukkit.Location;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.World;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.java.JavaPlugin;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.UUID;
-
 /**
- * PlotSquared API
- *
-
-
- * @version API 2.0
+ * PlotSquared API.
  *
+ * <p>Useful classes:
+ * <ul>
+ *     <li>{@link BukkitUtil}</li>
+ *     <li>{@link PlotPlayer}</li>
+ *     <li>{@link Plot}</li>
+ *     <li>{@link com.intellectualcrafters.plot.object.Location}</li>
+ *     <li>{@link PlotArea}</li>
+ *     <li>{@link PS}</li>
+ * </ul>
+ * @version 3.3.3
  */
-
 public class PlotAPI {
-    
+
     /**
-     * Permission that allows for admin access, this permission node will allow the player to use any part of the
-     * plugin, without limitations.
-     * @deprecated Use C.PERMISSION_ADMIN.s() instead
+     * Deprecated, does nothing.
+     * @param plugin not needed
+     * @deprecated Not needed
      */
     @Deprecated
-    public static final String ADMIN_PERMISSION = C.PERMISSION_ADMIN.s();
-    
+    public PlotAPI(JavaPlugin plugin) {}
+
+    public PlotAPI(){}
+
     /**
-     * @deprecated Use new PlotAPI() instead
-     */
-    @Deprecated
-    public PlotAPI(final JavaPlugin plugin) {}
-    
-    /**
-     * @see PS
-     *
-     * @deprecated Use this class if you just want to do a few simple things.<br>
-     *  - It will remain stable for future versions of the plugin
-     *  - The PlotPlayer and Plot class should be considered relatively safe
-     *  - For more advanced/intensive tasks you should consider using other classes
-     *
-     *
-     */
-    @Deprecated
-    public PlotAPI() {}
-    
-    /**
-     * Get all plots
+     * Get all plots.
      *
      * @return all plots
      *
@@ -100,29 +68,30 @@ public class PlotAPI {
     public Set<Plot> getAllPlots() {
         return PS.get().getPlots();
     }
-    
+
     /**
-     * Return all plots for a player
+     * Return all plots for a player.
      *
      * @param player Player, whose plots to search for
      *
      * @return all plots that a player owns
      */
-    public Set<Plot> getPlayerPlots(final Player player) {
+    public Set<Plot> getPlayerPlots(Player player) {
         return PS.get().getPlots(BukkitUtil.getPlayer(player));
     }
-    
+
     /**
-     * Add a plot world
+     * Add a plot world.
      *
      * @param plotArea Plot World Object
      * @see PS#addPlotArea(PlotArea)
      */
-    public void addPlotArea(final PlotArea plotArea) {
+    public void addPlotArea(PlotArea plotArea) {
         PS.get().addPlotArea(plotArea);
     }
-    
+
     /**
+     * Returns the PlotSquared configurations file.
      * @return main configuration
      *
      * @see PS#config
@@ -130,8 +99,9 @@ public class PlotAPI {
     public YamlConfiguration getConfig() {
         return PS.get().config;
     }
-    
+
     /**
+     * Get the PlotSquared storage file.
      * @return storage configuration
      *
      * @see PS#storage
@@ -139,10 +109,9 @@ public class PlotAPI {
     public YamlConfiguration getStorage() {
         return PS.get().storage;
     }
-    
+
     /**
-     * Get the main class for this plugin <br> - Contains a lot of fields and methods - not very well organized <br>
-     * Only use this if you really need it
+     * Get the main class for this plugin. Only use this if you really need it.
      *
      * @return PlotSquared PlotSquared Main Class
      *
@@ -151,18 +120,20 @@ public class PlotAPI {
     public PS getMain() {
         return PS.get();
     }
-    
+
     /**
-     * ChunkManager class contains several useful methods<br>
-     *  - Chunk deletion<br>
-     *  - Moving or copying regions<br>
-     *  - plot swapping<br>
-     *  - Entity tracking<br>
-     *  - region regeneration<br>
+     * 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
+     * @see ChunkManager
      */
     public ChunkManager getChunkManager() {
         return ChunkManager.manager;
@@ -170,129 +141,135 @@ public class PlotAPI {
 
     /**
      * Get the block/biome set queue
-     * @return SetQueue.IMP
+     * @return GlobalBlockQueue.IMP
      */
-    public SetQueue getSetQueue() {
-        return SetQueue.IMP;
+    public GlobalBlockQueue getBlockQueue() {
+        return GlobalBlockQueue.IMP;
     }
-    
+
     /**
-     * UUIDWrapper class has basic methods for getting UUIDS (it's recommended to use the UUIDHandler class instead)
+     * 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
+     * @see UUIDWrapper
      */
     public UUIDWrapper getUUIDWrapper() {
         return UUIDHandler.getUUIDWrapper();
     }
-    
+
     /**
      * Do not use this. Instead use FlagManager.[method] in your code.
      *  - Flag related stuff
      *
      * @return FlagManager
      *
-     * @see com.intellectualcrafters.plot.flag.FlagManager
+     * @deprecated Use {@link FlagManager} directly
      */
     @Deprecated
     public FlagManager getFlagManager() {
         return new FlagManager();
     }
-    
+
     /**
      * Do not use this. Instead use MainUtil.[method] in your code.
-     *  - Basic plot management stuff
      *
      * @return MainUtil
-     *
-     * @see MainUtil
+     * @deprecated Use {@link MainUtil} directly
      */
     @Deprecated
     public MainUtil getMainUtil() {
         return new MainUtil();
     }
-    
+
     /**
      * Do not use this. Instead use C.PERMISSION_[method] in your code.
-     *  - Basic permission management stuff
      *
      * @return Array of strings
      *
-     * @see com.intellectualcrafters.plot.util.Permissions
+     * @see Permissions
+     * @deprecated Use {@link C} to list all the permissions
      */
     @Deprecated
     public String[] getPermissions() {
-        final ArrayList<String> perms = new ArrayList<>();
-        for (final C c : C.values()) {
-            if ("static.permissions".equals(c.getCat())) {
-                perms.add(c.s());
+        ArrayList<String> perms = new ArrayList<>();
+        for (C caption : C.values()) {
+            if ("static.permissions".equals(caption.getCategory())) {
+                perms.add(caption.s());
             }
         }
         return perms.toArray(new String[perms.size()]);
     }
-    
+
     /**
-     * SchematicHandler class contains methods related to pasting, reading and writing schematics
+     * SchematicHandler class contains methods related to pasting, reading
+     * and writing schematics.
      *
      * @return SchematicHandler
      *
-     * @see com.intellectualcrafters.plot.util.SchematicHandler
+     * @see SchematicHandler
      */
     public SchematicHandler getSchematicHandler() {
         return SchematicHandler.manager;
     }
-    
+
     /**
      * Use C.[caption] instead
      *
      * @return C
-     *
-     * @see com.intellectualcrafters.plot.config.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
+     * Get the plot manager for a world. Most of these methods can be accessed
+     * through the MainUtil.
      *
-     * @param world Which manager to get
+     * @param world the world to retrieve the manager from
      *
      * @return PlotManager
      *
-     * @see com.intellectualcrafters.plot.object.PlotManager
+     * @see PlotManager
      * @see PS#getPlotManager(Plot)
      */
+    @SuppressWarnings("deprecation")
     @Deprecated
-    public PlotManager getPlotManager(final World world) {
+    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 Collections.emptySet();
         }
         return PS.get().getPlotAreas(world.getName());
     }
 
     /**
-     * Get the plot manager for a world. - Contains useful low level methods for plot merging, clearing, and
-     * tessellation
+     * Get the plot manager for a world. Contains useful low level methods for
+     * plot merging, clearing, and tessellation.
      *
-     * @param world
+     * @param world The world
      *
      * @return PlotManager
      *
      * @see PS#getPlotManager(Plot)
-     * @see com.intellectualcrafters.plot.object.PlotManager
+     * @see PlotManager
      */
     @Deprecated
-    public PlotManager getPlotManager(final String world) {
+    public PlotManager getPlotManager(String world) {
         Set<PlotArea> areas = PS.get().getPlotAreas(world);
         switch (areas.size()) {
             case 0:
@@ -304,38 +281,40 @@ public class PlotAPI {
                 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
+     * Get the settings for a world (settings bundled in PlotArea class). You
+     * will need to downcast for the specific settings a Generator has. e.g.
+     * DefaultPlotWorld class implements PlotArea
      *
-     * @param world (to get settings of)
+     * @param world The World
      *
-     * @return PlotArea class for that world ! will return null if not a plot world world
+     * @return The {@link PlotArea} for the world or null if not in plotworld
      *
      * @see #getPlotAreas(World)
-     * @see com.intellectualcrafters.plot.object.PlotArea
+     * @see PlotArea
      */
+    @SuppressWarnings("deprecation")
     @Deprecated
-    public PlotArea getWorldSettings(final World world) {
+    public PlotArea getWorldSettings(World world) {
         if (world == null) {
             return null;
         }
         return getWorldSettings(world.getName());
     }
-    
+
     /**
-     * Get the settings for a world (settings bundled in PlotArea class)
+     * Get the settings for a world.
      *
-     * @param world (to get settings of)
+     * @param world the world to retrieve settings from
      *
-     * @return PlotArea class for that world ! will return null if not a plot world 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
+     * @see PlotArea
      */
     @Deprecated
-    public PlotArea getWorldSettings(final String world) {
+    public PlotArea getWorldSettings(String world) {
         if (world == null) {
             return null;
         }
@@ -350,92 +329,78 @@ public class PlotAPI {
                 return null;
         }
     }
-    
+
     /**
      * Send a message to a player.
      *
-     * @param player Player that will receive the message
-     * @param c      (Caption)
+     * @param player the recipient of the message
+     * @param caption the message
      *
      * @see MainUtil#sendMessage(PlotPlayer, C, String...)
-     * com.intellectualcrafters.plot.config.C, String...)
      */
-    public void sendMessage(final Player player, final C c) {
-        MainUtil.sendMessage(BukkitUtil.getPlayer(player), c);
+    public void sendMessage(Player player, C caption) {
+        MainUtil.sendMessage(BukkitUtil.getPlayer(player), caption);
     }
-    
+
     /**
-     * Send a message to a player. - Supports color codes
+     * Send a message to a player. The message supports color codes.
      *
-     * @param player Player that will receive the message
-     * @param string The message
+     * @param player the recipient of the message
+     * @param string the message
      *
      * @see MainUtil#sendMessage(PlotPlayer, String)
      */
-    public void sendMessage(final Player player, final String string) {
+    public void sendMessage(Player player, String string) {
         MainUtil.sendMessage(BukkitUtil.getPlayer(player), string);
     }
-    
+
     /**
-     * Send a message to the console. - Supports color codes
+     * Send a message to the console. The message supports color codes.
      *
-     * @param msg Message that should be sent to the console
+     * @param message the message
      *
      * @see MainUtil#sendConsoleMessage(C, String...)
      */
-    public void sendConsoleMessage(final String msg) {
-        PS.log(msg);
+    public void sendConsoleMessage(String message) {
+        PS.log(message);
     }
-    
+
     /**
-     * Send a message to the console
+     * Send a message to the console.
      *
-     * @param c (Caption)
+     * @param caption the message
      *
      * @see #sendConsoleMessage(String)
-     * @see com.intellectualcrafters.plot.config.C
+     * @see C
      */
-    public void sendConsoleMessage(final C c) {
-        sendConsoleMessage(c.s());
+    public void sendConsoleMessage(C caption) {
+        sendConsoleMessage(caption.s());
     }
-    
+
     /**
-     * Register a flag for use in plots
+     * Register a flag for use in plots.
      *
-     * @param flag Flag that should be registered
+     * @param flag the flag being registered
      *
-     * @see com.intellectualcrafters.plot.flag.FlagManager#addFlag(com.intellectualcrafters.plot.flag.AbstractFlag)
-     * @see com.intellectualcrafters.plot.flag.AbstractFlag
      */
-    public void addFlag(final AbstractFlag flag) {
-        FlagManager.addFlag(flag);
+    public void addFlag(Flag<?> flag) {
+        Flags.registerFlag(flag);
     }
-    
+
     /**
-     * get all the currently registered flags
+     * Get a plot based on the ID.
      *
-     * @return array of Flag[]
-     *
-     * @see com.intellectualcrafters.plot.flag.FlagManager#getFlags()
-     * @see com.intellectualcrafters.plot.flag.AbstractFlag
-     */
-    public AbstractFlag[] getFlags() {
-        return FlagManager.getFlags().toArray(new AbstractFlag[FlagManager.getFlags().size()]);
-    }
-    
-    /**
-     * Get a plot based on the ID
-     *
-     * @param world World in which the plot is located
-     * @param x     Plot Location X Co-ord
-     * @param z     Plot Location Z Co-ord
+     * @param world the world the plot is located in
+     * @param x The PlotID x coordinate
+     * @param z The PlotID y coordinate
      *
      * @return plot, null if ID is wrong
      *
      * @see PlotArea#getPlot(PlotId)
      */
+    @SuppressWarnings("deprecation")
     @Deprecated
-    public Plot getPlot(final World world, final int x, final int z) {
+    public Plot getPlot(World world, int x, int z) {
         if (world == null) {
             return null;
         }
@@ -445,77 +410,78 @@ public class PlotAPI {
         }
         return area.getPlot(new PlotId(x, z));
     }
-    
+
     /**
-     * Get a plot based on the location
+     * Get a plot based on the location.
      *
-     * @param l The location that you want to to retrieve the plot from
-     *
-     * @return plot if found, otherwise it creates a temporary plot-
-     *
-     * @see Plot
-     */
-    public Plot getPlot(final Location l) {
-        if (l == null) {
-            return null;
-        }
-        return BukkitUtil.getLocation(l).getPlot();
-    }
-    
-    /**
-     * Get a plot based on the player location
-     *
-     * @param player Get the current plot for the player location
+     * @param location the location to check
      *
      * @return plot if found, otherwise it creates a temporary plot
      *
-     * @see #getPlot(org.bukkit.Location)
      * @see Plot
      */
-    public Plot getPlot(final Player player) {
+    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 the player to check
+     *
+     * @return plot if found, otherwise it creates a temporary plot
+     *
+     * @see #getPlot(Location)
+     * @see Plot
+     */
+    public Plot getPlot(Player player) {
         return this.getPlot(player.getLocation());
     }
-    
+
     /**
-     * Check whether or not a player has a plot
+     * 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)
      */
+    @SuppressWarnings("deprecation")
     @Deprecated
-    public boolean hasPlot(final World world, final Player player) {
-        return getPlots(world, player, true) != null && getPlots(world, player, true).length > 0;
+    public boolean hasPlot(World world, Player player) {
+        return getPlots(world, player, true).length > 0;
     }
-    
+
     /**
-     * Get all plots for the player
+     * Get all plots for the player.
      *
-     * @param plr        to search for
-     * @param just_owner should we just search for owner? Or with rights?
+     * @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(final World world, final Player plr, final boolean just_owner) {
-        final ArrayList<Plot> pPlots = new ArrayList<>();
-        UUID uuid = BukkitUtil.getPlayer(plr).getUUID();
-        for (final Plot plot : PS.get().getPlots(world.getName())) {
-            if (just_owner) {
+    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);
-                }
+            } else if (plot.isAdded(uuid)) {
+                pPlots.add(plot);
             }
         }
         return pPlots.toArray(new Plot[pPlots.size()]);
     }
-    
+
     /**
-     * Get all plots for the world
+     * Get all plots for the world.
      *
      * @param world to get plots of
      *
@@ -525,44 +491,45 @@ public class PlotAPI {
      * @see Plot
      */
     @Deprecated
-    public Plot[] getPlots(final World world) {
+    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
+     * Get all plot worlds.
      *
      * @return World[] - array of plot worlds
      *
      */
+    @SuppressWarnings("deprecation")
     @Deprecated
     public String[] getPlotWorlds() {
         Set<String> plotWorldStrings = PS.get().getPlotWorldStrings();
         return plotWorldStrings.toArray(new String[plotWorldStrings.size()]);
     }
-    
+
     /**
-     * Get if plot world
+     * Get if plotworld.
      *
-     * @param world (to check if plot world)
+     * @param world The world to check
      *
      * @return boolean (if plot world or not)
      *
      * @see PS#hasPlotArea(String)
      */
     @Deprecated
-    public boolean isPlotWorld(final World world) {
+    public boolean isPlotWorld(World world) {
         return PS.get().hasPlotArea(world.getName());
     }
-    
+
     /**
-     * Get plot locations
+     * Get plot locations.
      *
-     * @param p Plot that you want to get the locations for
+     * @param plot Plot to get the locations for
      *
      * @return [0] = bottomLc, [1] = topLoc, [2] = home
      *
@@ -570,28 +537,32 @@ public class PlotAPI {
      *
      * @see Plot
      */
+    @SuppressWarnings("deprecation")
     @Deprecated
-    public Location[] getLocations(final Plot p) {
-        return new Location[] { BukkitUtil.getLocation(p.getBottom()), BukkitUtil.getLocation(p.getTop()), BukkitUtil.getLocation(p.getHome()) };
+    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
+     * Get home location.
      *
-     * @param p Plot that you want to get the location for
+     * @param plot Plot that you want to get the location for
      *
      * @return plot bottom location
      *
      * @see Plot
      */
-    public Location getHomeLocation(final Plot p) {
-        return BukkitUtil.getLocation(p.getHome());
+    public Location getHomeLocation(Plot plot) {
+        return BukkitUtil.getLocation(plot.getHome());
     }
-    
+
     /**
-     * Get Bottom Location (min, min, min)
+     * Get Bottom Location (min, min, min).
      *
-     * @param p Plot that you want to get the location for
+     * @param plot Plot that you want to get the location for
      *
      * @return plot bottom location
      *
@@ -599,56 +570,54 @@ public class PlotAPI {
      *
      * @see Plot
      */
+    @SuppressWarnings("deprecation")
     @Deprecated
-    public Location getBottomLocation(final Plot p) {
-        return BukkitUtil.getLocation(p.getBottom());
+    public Location getBottomLocation(Plot plot) {
+        return BukkitUtil.getLocation(plot.getCorners()[0]);
     }
-    
+
     /**
-     * Get Top Location (max, max, max)
+     * Get Top Location (max, max, max).
      *
-     * @param p Plot that you want to get the location for
+     * @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
      */
+    @SuppressWarnings("deprecation")
     @Deprecated
-    public Location getTopLocation(final Plot p) {
-        return BukkitUtil.getLocation(p.getTop());
+    public Location getTopLocation(Plot plot) {
+        return BukkitUtil.getLocation(plot.getCorners()[1]);
     }
-    
+
     /**
-     * Check whether or not a player is in a plot
+     * Check whether or not a player is in a plot.
      *
      * @param player who we're checking for
      *
      * @return true if the player is in a plot, false if not-
      *
      */
-    public boolean isInPlot(final Player player) {
+    public boolean isInPlot(Player player) {
         return getPlot(player) != null;
     }
-    
+
     /**
-     * Register a subcommand
-     *
+     * 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
+     * @see SubCommand
      */
-    public void registerCommand(final SubCommand c) {
-        if (c.getCommand() != null) {
-            MainCommand.getInstance().addCommand(c);
-        } else {
-            MainCommand.getInstance().createCommand(c);
-        }
+    @Deprecated
+    public void registerCommand(SubCommand c) {
+        PS.debug("SubCommands are now registered on creation");
     }
-    
+
     /**
-     * Get the PlotSquared class
+     * Get the PlotSquared class.
      *
      * @return PlotSquared Class
      *
@@ -657,9 +626,9 @@ public class PlotAPI {
     public PS getPlotSquared() {
         return PS.get();
     }
-    
+
     /**
-     * Get the player plot count
+     * 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
@@ -667,15 +636,15 @@ public class PlotAPI {
      * @return the number of plots the player has
      *
      */
-    public int getPlayerPlotCount(final World world, final Player player) {
+    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
+     * 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
@@ -686,73 +655,78 @@ public class PlotAPI {
      *
      * @see Plot
      */
-    public Set<Plot> getPlayerPlots(final World world, final Player player) {
+    public Set<Plot> getPlayerPlots(World world, Player player) {
         if (world == null) {
             return new HashSet<>();
         }
-        return BukkitUtil.getPlayer(player).getPlots(world.getName());
+        return PlotPlayer.wrap(player).getPlots(world.getName());
     }
-    
+
     /**
-     * Get the numbers of plots, which the player is able to build in
+     * Get the numbers of plots, which the player is able to build in.
      *
-     * @param player Player, for whom we're getting the plots (trusted, member and owner)
+     * @param player player, for whom we're getting the plots
      *
      * @return the number of allowed plots
      *
      */
-    public int getAllowedPlots(final Player player) {
-        final PlotPlayer pp = BukkitUtil.getPlayer(player);
-        return pp.getAllowedPlots();
+    public int getAllowedPlots(Player player) {
+        PlotPlayer plotPlayer = PlotPlayer.wrap(player);
+        return plotPlayer.getAllowedPlots();
     }
-    
+
     /**
-     * Get the PlotPlayer for a player<br>
-     *  - The PlotPlayer is usually cached and will provide useful functions relating to players
+     * 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
-     * @return
+     * @param player the player to wrap
+     * @return a {@code PlotPlayer}
      */
-    public PlotPlayer wrapPlayer(final Player player) {
+    public PlotPlayer wrapPlayer(Player player) {
         return PlotPlayer.wrap(player);
     }
-    
+
     /**
-     * Get the PlotPlayer for a UUID (Please note that PlotSquared can be configured to provide different UUIDs than bukkit)
+     * Get the PlotPlayer for a UUID.
+     *
+     * <p><i>Please note that PlotSquared can be configured to provide
+     * different UUIDs than bukkit</i>
      *
      * @see PlotPlayer#wrap(Object)
      *
-     * @param uuid
-     * @return
+     * @param uuid the uuid of the player to wrap
+     * @return a {@code PlotPlayer}
      */
-    public PlotPlayer wrapPlayer(final UUID uuid) {
+    public PlotPlayer wrapPlayer(UUID uuid) {
         return PlotPlayer.wrap(uuid);
     }
-    
+
     /**
-     * Get the PlotPlayer for a username
+     * Get the PlotPlayer for a username.
      *
      * @see PlotPlayer#wrap(Object)
      *
-     * @param player
-     * @return
+     * @param player the player to wrap
+     * @return a {@code PlotPlayer}
      */
-    public PlotPlayer wrapPlayer(final String player) {
+    public PlotPlayer wrapPlayer(String player) {
         return PlotPlayer.wrap(player);
     }
-    
+
     /**
-     * Get the PlotPlayer for an offline player<br>
-     * Note that this will work if the player is offline, however not all functionality will work
+     * Get the PlotPlayer for an offline player.
+     *
+     * <p>Note that this will work if the player is offline, however not all
+     * functionality will work.
      *
      * @see PlotPlayer#wrap(Object)
      *
-     * @param player
-     * @return
+     * @param player the player to wrap
+     * @return a {@code PlotPlayer}
      */
-    public PlotPlayer wrapPlayer(final OfflinePlayer player) {
+    public PlotPlayer wrapPlayer(OfflinePlayer player) {
         return PlotPlayer.wrap(player);
     }
 }

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

@@ -3,37 +3,88 @@ package com.plotsquared.bukkit;
 import com.intellectualcrafters.configuration.ConfigurationSection;
 import com.intellectualcrafters.plot.IPlotMain;
 import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.commands.MainCommand;
 import com.intellectualcrafters.plot.config.C;
 import com.intellectualcrafters.plot.config.ConfigurationNode;
 import com.intellectualcrafters.plot.config.Settings;
-import com.intellectualcrafters.plot.flag.FlagManager;
 import com.intellectualcrafters.plot.generator.GeneratorWrapper;
 import com.intellectualcrafters.plot.generator.HybridGen;
 import com.intellectualcrafters.plot.generator.HybridUtils;
 import com.intellectualcrafters.plot.generator.IndependentPlotGenerator;
-import com.intellectualcrafters.plot.object.*;
-import com.intellectualcrafters.plot.util.*;
+import com.intellectualcrafters.plot.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.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.util.block.QueueProvider;
 import com.intellectualcrafters.plot.uuid.UUIDWrapper;
-import com.plotsquared.bukkit.commands.DebugUUID;
 import com.plotsquared.bukkit.database.plotme.ClassicPlotMeConnector;
 import com.plotsquared.bukkit.database.plotme.LikePlotMeConverter;
 import com.plotsquared.bukkit.database.plotme.PlotMeConnector_017;
 import com.plotsquared.bukkit.generator.BukkitPlotGenerator;
-import com.plotsquared.bukkit.listeners.*;
-import com.plotsquared.bukkit.listeners.worldedit.WEListener;
-import com.plotsquared.bukkit.titles.DefaultTitle;
-import com.plotsquared.bukkit.util.*;
-import com.plotsquared.bukkit.util.block.FastQueue_1_7;
-import com.plotsquared.bukkit.util.block.FastQueue_1_8;
-import com.plotsquared.bukkit.util.block.FastQueue_1_8_3;
-import com.plotsquared.bukkit.util.block.SlowQueue;
-import com.plotsquared.bukkit.uuid.*;
-import com.sk89q.worldedit.bukkit.WorldEditPlugin;
-import org.bukkit.*;
+import 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.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.BukkitLocalQueue;
+import com.plotsquared.bukkit.util.block.BukkitLocalQueue_1_7;
+import com.plotsquared.bukkit.util.block.BukkitLocalQueue_1_8;
+import com.plotsquared.bukkit.util.block.BukkitLocalQueue_1_8_3;
+import com.plotsquared.bukkit.util.block.BukkitLocalQueue_1_9;
+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.WorldEdit;
+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.LivingEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Listener;
 import org.bukkit.generator.ChunkGenerator;
@@ -41,133 +92,122 @@ import org.bukkit.metadata.MetadataValue;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.java.JavaPlugin;
 
-import java.io.File;
-import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.*;
+public final class BukkitMain extends JavaPlugin implements Listener, IPlotMain {
+
+    public static WorldEdit worldEdit;
 
-public class BukkitMain extends JavaPlugin implements Listener, IPlotMain {
-    
-    public static BukkitMain THIS;
-    public static WorldEditPlugin worldEdit;
-    
     private int[] version;
-    
+
     @Override
     public int[] getServerVersion() {
-        if (version == null) {
+        if (this.version == null) {
             try {
-                version = new int[3];
-                final String[] split = Bukkit.getBukkitVersion().split("-")[0].split("\\.");
-                version[0] = Integer.parseInt(split[0]);
-                version[1] = Integer.parseInt(split[1]);
+                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) {
-                    version[2] = Integer.parseInt(split[2]);
+                    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 new int[]{1, 9, 2};
             }
         }
-        return version;
+        return this.version;
     }
-    
+
     @Override
     public void onEnable() {
-        THIS = this;
         new PS(this, "Bukkit");
     }
-    
+
     @Override
     public void onDisable() {
         PS.get().disable();
         Bukkit.getScheduler().cancelTasks(this);
-        THIS = null;
     }
-    
+
     @Override
     public void log(String message) {
-        if (message == null) {
-            return;
+        try {
+            message = C.color(message);
+            if (!Settings.Chat.CONSOLE_COLOR) {
+                message = ChatColor.stripColor(message);
+            }
+            this.getServer().getConsoleSender().sendMessage(message);
+        } catch (Throwable ignored) {
+            System.out.println(ConsoleColors.fromString(message));
         }
-        if ((THIS != null) && (Bukkit.getServer().getConsoleSender() != null)) {
-            try {
-                message = C.color(message);
-                if (!Settings.CONSOLE_COLOR) {
-                    message = ChatColor.stripColor(message);
-                }
-                Bukkit.getServer().getConsoleSender().sendMessage(message);
-                return;
-            } catch (final Throwable e) {}
-        }
-        System.out.println(ConsoleColors.fromString(message));
     }
-    
+
     @Override
     public void disable() {
-        if (THIS != null) {
-            onDisable();
-        }
+        onDisable();
     }
-    
+
     @Override
     public int[] getPluginVersion() {
-        final String[] split = getDescription().getVersion().split("\\.");
-        return new int[] { Integer.parseInt(split[0]), Integer.parseInt(split[1]), Integer.parseInt(split[2]) };
+        String ver = getDescription().getVersion();
+        if (ver.contains("-")) {
+            ver = ver.split("-")[0];
+        }
+        String[] split = ver.split("\\.");
+        return new int[]{Integer.parseInt(split[0]), Integer.parseInt(split[1]), Integer.parseInt(split[2])};
     }
-    
+
     @Override
     public void registerCommands() {
-        final BukkitCommand bcmd = new BukkitCommand();
-        final PluginCommand plotCommand = getCommand("plots");
-        plotCommand.setExecutor(bcmd);
+        BukkitCommand bukkitCommand = new BukkitCommand();
+        PluginCommand plotCommand = getCommand("plots");
+        plotCommand.setExecutor(bukkitCommand);
         plotCommand.setAliases(Arrays.asList("p", "ps", "plotme", "plot"));
-        plotCommand.setTabCompleter(bcmd);
-        MainCommand.getInstance().addCommand(new DebugUUID());
+        plotCommand.setTabCompleter(bukkitCommand);
     }
-    
+
     @Override
     public File getDirectory() {
         return getDataFolder();
     }
-    
+
     @Override
     public File getWorldContainer() {
         return Bukkit.getWorldContainer();
     }
-    
+
     @Override
     public TaskManager getTaskManager() {
-        return new BukkitTaskManager();
+        return new BukkitTaskManager(this);
     }
-    
+
     @Override
     public void runEntityTask() {
-        log(C.PREFIX.s() + "KillAllEntities started.");
+        PS.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);
+                    public void run(PlotArea plotArea) {
+                        World world = Bukkit.getWorld(plotArea.worldname);
                         try {
                             if (world == null) {
                                 return;
                             }
                             List<Entity> entities = world.getEntities();
-                            Iterator<Entity> iter = entities.iterator();
-                            while (iter.hasNext()) {
-                                Entity entity = iter.next();
+                            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 LINGERING_POTION:
+                                    case AREA_EFFECT_CLOUD:
                                     case EXPERIENCE_ORB:
                                     case LEASH_HITCH:
                                     case FIREWORK:
@@ -175,23 +215,25 @@ public class BukkitMain extends JavaPlugin implements Listener, IPlotMain {
                                     case LIGHTNING:
                                     case WITHER_SKULL:
                                     case UNKNOWN:
-                                    case PLAYER: {
-                                        // non moving / unremovable
+                                    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: {
+                                    case ARROW:
                                         // managed elsewhere | projectile
                                         continue;
-                                    }
-                                    case ARMOR_STAND:
                                     case ITEM_FRAME:
-                                    case PAINTING: {
-                                        // TEMPORARILY CLASSIFY AS VEHICLE
-                                    }
+                                    case PAINTING:
+                                        // Not vehicles
+                                        continue;
+                                    case ARMOR_STAND:
+                                        // Tempirarily classify as vehicle
                                     case MINECART:
                                     case MINECART_CHEST:
                                     case MINECART_COMMAND:
@@ -200,14 +242,14 @@ public class BukkitMain extends JavaPlugin implements Listener, IPlotMain {
                                     case MINECART_MOB_SPAWNER:
                                     case MINECART_TNT:
                                     case BOAT: {
-                                        if (!Settings.KILL_ROAD_VEHICLES) {
+                                        if (!Settings.Enabled_Components.KILL_ROAD_VEHICLES) {
                                             continue;
                                         }
-                                        com.intellectualcrafters.plot.object.Location loc = BukkitUtil.getLocation(entity.getLocation());
-                                        Plot plot = loc.getPlot();
+                                        com.intellectualcrafters.plot.object.Location location = BukkitUtil.getLocation(entity.getLocation());
+                                        Plot plot = location.getPlot();
                                         if (plot == null) {
-                                            if (loc.isPlotArea()) {
-                                                iter.remove();
+                                            if (location.isPlotArea()) {
+                                                iterator.remove();
                                                 entity.remove();
                                             }
                                             continue;
@@ -218,22 +260,21 @@ public class BukkitMain extends JavaPlugin implements Listener, IPlotMain {
                                         }
                                         Plot origin = (Plot) meta.get(0).value();
                                         if (!plot.equals(origin.getBasePlot(false))) {
-                                            iter.remove();
+                                            iterator.remove();
                                             entity.remove();
                                         }
                                         continue;
                                     }
                                     case SMALL_FIREBALL:
                                     case FIREBALL:
-                                    case DROPPED_ITEM: {
+                                    case DRAGON_FIREBALL:
+                                    case DROPPED_ITEM:
                                         // dropped item
                                         continue;
-                                    }
                                     case PRIMED_TNT:
-                                    case FALLING_BLOCK: {
+                                    case FALLING_BLOCK:
                                         // managed elsewhere
                                         continue;
-                                    }
                                     case BAT:
                                     case BLAZE:
                                     case CAVE_SPIDER:
@@ -266,24 +307,33 @@ public class BukkitMain extends JavaPlugin implements Listener, IPlotMain {
                                     case WITHER:
                                     case WOLF:
                                     case ZOMBIE:
-                                    default: {
-                                        if (!Settings.KILL_ROAD_MOBS) {
+                                    case SHULKER:
+                                    default:
+                                        if (!Settings.Enabled_Components.KILL_ROAD_MOBS) {
                                             continue;
                                         }
-                                        final Location loc = entity.getLocation();
-                                        if (BukkitUtil.getLocation(loc).isPlotRoad()) {
-                                            final Entity passenger = entity.getPassenger();
-                                            if (!(passenger instanceof Player)) {
-                                                if (entity.getMetadata("keep").isEmpty()) {
-                                                    iter.remove();
+                                        Location location = entity.getLocation();
+                                        if (BukkitUtil.getLocation(location).isPlotRoad()) {
+                                            if (entity instanceof LivingEntity) {
+                                                LivingEntity livingEntity = (LivingEntity) entity;
+                                                if (!livingEntity.isLeashed() || !entity.hasMetadata("keep")) {
+                                                    Entity passenger = entity.getPassenger();
+                                                    if (!(passenger instanceof Player) && entity.getMetadata("keep").isEmpty()) {
+                                                        iterator.remove();
+                                                        entity.remove();
+                                                    }
+                                                }
+                                            } else {
+                                                Entity passenger = entity.getPassenger();
+                                                if (!(passenger instanceof Player) && entity.getMetadata("keep").isEmpty()) {
+                                                    iterator.remove();
                                                     entity.remove();
                                                 }
                                             }
                                         }
-                                    }
                                 }
                             }
-                        } catch (final Throwable e) {
+                        } catch (Throwable e) {
                             e.printStackTrace();
                         }
                     }
@@ -291,107 +341,107 @@ public class BukkitMain extends JavaPlugin implements Listener, IPlotMain {
             }
         }, 20);
     }
-    
+
     @Override
-    final public ChunkGenerator getDefaultWorldGenerator(final String world, final String id) {
-        final HybridGen result = new HybridGen();
+    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() {
-        getServer().getPluginManager().registerEvents(new PlayerEvents(), this);
+        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);
+            try {
+                getServer().getPluginManager().registerEvents(new PlayerEvents_1_8(), this);
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
         }
         if (PS.get().checkVersion(getServerVersion(), 1, 8, 3)) {
-            getServer().getPluginManager().registerEvents(new PlayerEvents_1_8_3(), this);
+            try {
+                getServer().getPluginManager().registerEvents(new PlayerEvents183(), this);
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        }
+        if (PS.get().checkVersion(getServerVersion(), 1, 9, 0)) {
+            try {
+                getServer().getPluginManager().registerEvents(new PlayerEvents_1_9(main), this);
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
         }
     }
-    
+
     @Override
     public void registerInventoryEvents() {
         // Part of PlayerEvents - can be moved if necessary
     }
-    
+
     @Override
     public void registerPlotPlusEvents() {
         PlotPlusListener.startRunnable(this);
         getServer().getPluginManager().registerEvents(new PlotPlusListener(), this);
     }
-    
+
     @Override
     public void registerForceFieldEvents() {
         getServer().getPluginManager().registerEvents(new ForceFieldListener(), this);
     }
-    
+
     @Override
     public boolean initWorldEdit() {
         if (getServer().getPluginManager().getPlugin("WorldEdit") != null) {
-            BukkitMain.worldEdit = (WorldEditPlugin) getServer().getPluginManager().getPlugin("WorldEdit");
-            final String version = BukkitMain.worldEdit.getDescription().getVersion();
-            if ((version != null) && version.startsWith("5.")) {
-                log("&cThis version of WorldEdit does not support PlotSquared.");
-                log("&cPlease use WorldEdit 6+ for masking support");
-                log("&c - http://builds.enginehub.org/job/worldedit");
-            } else {
-                getServer().getPluginManager().registerEvents(new WEListener(), this);
-                return true;
-            }
+            worldEdit = WorldEdit.getInstance();
+            return true;
         }
         return false;
     }
-    
+
     @Override
     public EconHandler getEconomyHandler() {
         try {
-            final BukkitEconHandler econ = new BukkitEconHandler();
+            BukkitEconHandler econ = new BukkitEconHandler();
             if (econ.init()) {
                 return econ;
             }
-        } catch (final Throwable ignored) {
+        } catch (Throwable ignored) {
+            PS.debug("No economy detected!");
         }
         return null;
     }
-    
+
     @Override
-    public PlotQueue initPlotQueue() {
+    public QueueProvider initBlockQueue() {
         try {
             new SendChunk();
             MainUtil.canSendChunk = true;
-        } catch (final Throwable e) {
+        } catch (ClassNotFoundException | NoSuchFieldException | NoSuchMethodException e) {
             e.printStackTrace();
             MainUtil.canSendChunk = false;
         }
+        if (PS.get().checkVersion(getServerVersion(), 1, 9, 0)) {
+            return QueueProvider.of(BukkitLocalQueue_1_9.class, BukkitLocalQueue.class);
+        }
+        if (PS.get().checkVersion(getServerVersion(), 1, 8, 3)) {
+            return QueueProvider.of(BukkitLocalQueue_1_8_3.class, BukkitLocalQueue.class);
+        }
         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();
+            return QueueProvider.of(BukkitLocalQueue_1_8.class, BukkitLocalQueue.class);
         }
+        return QueueProvider.of(BukkitLocalQueue_1_7.class, BukkitLocalQueue.class);
     }
-    
+
     @Override
     public WorldUtil initWorldUtil() {
         return new BukkitUtil();
     }
-    
+
     @Override
     public boolean initPlotMeConverter() {
         TaskManager.runTaskLaterAsync(new Runnable() {
@@ -403,22 +453,19 @@ public class BukkitMain extends JavaPlugin implements Listener, IPlotMain {
                 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);
+        return Bukkit.getPluginManager().getPlugin("PlotMe") != null;
     }
-    
+
     @Override
-    public GeneratorWrapper<?> getGenerator(final String world, final String name) {
+    public GeneratorWrapper<?> getGenerator(String world, String name) {
         if (name == null) {
             return null;
         }
-        final Plugin gen_plugin = Bukkit.getPluginManager().getPlugin(name);
-        if ((gen_plugin != null) && gen_plugin.isEnabled()) {
-            ChunkGenerator gen = gen_plugin.getDefaultWorldGenerator(world, "");
+        Plugin genPlugin = Bukkit.getPluginManager().getPlugin(name);
+        if (genPlugin != null && genPlugin.isEnabled()) {
+            ChunkGenerator gen = genPlugin.getDefaultWorldGenerator(world, "");
             if (gen instanceof GeneratorWrapper<?>) {
                 return (GeneratorWrapper<?>) gen;
             }
@@ -427,218 +474,193 @@ public class BukkitMain extends JavaPlugin implements Listener, IPlotMain {
             return new BukkitPlotGenerator(new HybridGen());
         }
     }
-    
+
     @Override
     public HybridUtils initHybridUtils() {
         return new BukkitHybridUtils();
     }
-    
+
     @Override
     public SetupUtils initSetupUtils() {
         return new BukkitSetupUtils();
     }
-    
+
     @Override
     public UUIDHandlerImplementation initUUIDHandler() {
-        final boolean checkVersion = PS.get().checkVersion(getServerVersion(), 1, 7, 6);
+        boolean checkVersion = PS.get().checkVersion(getServerVersion(), 1, 7, 6);
         UUIDWrapper wrapper;
-        if (Settings.OFFLINE_MODE) {
-            if (Settings.UUID_LOWERCASE) {
-                wrapper = (new LowerOfflineUUIDWrapper());
+        if (Settings.UUID.OFFLINE) {
+            if (Settings.UUID.FORCE_LOWERCASE) {
+                wrapper = new LowerOfflineUUIDWrapper();
             } else {
-                wrapper = (new OfflineUUIDWrapper());
+                wrapper = new OfflineUUIDWrapper();
             }
-            Settings.OFFLINE_MODE = true;
+            Settings.UUID.OFFLINE = true;
         } else if (checkVersion) {
-            wrapper = (new DefaultUUIDWrapper());
-            Settings.OFFLINE_MODE = false;
+            wrapper = new DefaultUUIDWrapper();
+            Settings.UUID.OFFLINE = false;
         } else {
-            if (Settings.UUID_LOWERCASE) {
-                wrapper = (new LowerOfflineUUIDWrapper());
+            if (Settings.UUID.FORCE_LOWERCASE) {
+                wrapper = new LowerOfflineUUIDWrapper();
             } else {
-                wrapper = (new OfflineUUIDWrapper());
+                wrapper = new OfflineUUIDWrapper();
             }
-            Settings.OFFLINE_MODE = true;
+            Settings.UUID.OFFLINE = true;
         }
         if (!checkVersion) {
-            log(C.PREFIX.s() + " &c[WARN] Titles are disabled - please update your version of Bukkit to support this feature.");
+            PS.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();
+            AbstractTitle.TITLE_CLASS = new DefaultTitle_19();
             if (wrapper instanceof DefaultUUIDWrapper || wrapper.getClass() == OfflineUUIDWrapper.class && !Bukkit.getOnlineMode()) {
-                Settings.TWIN_MODE_UUID = true;
+                Settings.UUID.NATIVE_UUID_PROVIDER = true;
             }
         }
-        if (Settings.OFFLINE_MODE) {
-            log(C.PREFIX.s() + " &6PlotSquared is using Offline Mode UUIDs either because of user preference, or because you are using an old version of Bukkit");
+        if (Settings.UUID.OFFLINE) {
+            PS.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.s() + " &6PlotSquared is using online UUIDs");
+            PS.log(C.PREFIX + " &6PlotSquared is using online UUIDs");
+        }
+        if (Settings.UUID.USE_SQLUUIDHANDLER) {
+            return new SQLUUIDHandler(wrapper);
+        } else {
+            return new FileUUIDHandler(wrapper);
         }
-        return Settings.USE_SQLUUIDHANDLER ? new SQLUUIDHandler(wrapper) : new FileUUIDHandler(wrapper);
     }
-    
+
     @Override
     public ChunkManager initChunkManager() {
         return new BukkitChunkManager();
     }
-    
+
     @Override
     public EventUtil initEventUtil() {
         return new BukkitEventUtil();
     }
-    
+
     @Override
-    public void unregister(final PlotPlayer player) {
+    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() {
-        try {
-            final Metrics metrics = new Metrics(this);
-            metrics.start();
-            log(C.PREFIX.s() + "&6Metrics enabled.");
-        } catch (IOException e) {
-            log(C.PREFIX.s() + "&cFailed to load up metrics.");
-        }
+        Metrics metrics = new Metrics(this);
+        metrics.start();
+        PS.log(C.PREFIX + "&6Metrics enabled.");
     }
-    
+
     @Override
-    public void setGenerator(final String worldname) {
-        World world = BukkitUtil.getWorld(worldname);
+    public void setGenerator(String worldName) {
+        World world = BukkitUtil.getWorld(worldName);
         if (world == null) {
             // create world
-            final ConfigurationSection worldConfig = PS.get().config.getConfigurationSection("worlds." + worldname);
-            String manager = worldConfig.getString("generator.plugin");
-            if (manager == null) {
-                manager = "PlotSquared";
-            }
-            String generator = worldConfig.getString("generator.init");
-            if (generator == null) {
-                generator = manager;
-            }
-            
-            final int type = worldConfig.getInt("generator.type");
-            final int terrain = worldConfig.getInt("generator.terrain");
-            final SetupObject setup = new SetupObject();
+            ConfigurationSection worldConfig = PS.get().worlds.getConfigurationSection("worlds." + worldName);
+            String manager = worldConfig.getString("generator.plugin", "PlotSquared");
+            SetupObject setup = new SetupObject();
             setup.plotManager = manager;
-            setup.setupGenerator = generator;
-            setup.type = type;
-            setup.terrain = terrain;
+            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;
+            setup.world = worldName;
             SetupUtils.manager.setupWorld(setup);
         } else {
             try {
-                if (!PS.get().hasPlotArea(worldname)) {
-                    SetGenCB.setGenerator(BukkitUtil.getWorld(worldname));
+                if (!PS.get().hasPlotArea(worldName)) {
+                    SetGenCB.setGenerator(BukkitUtil.getWorld(worldName));
                 }
-            } catch (final Exception e) {
-                log("Failed to reload world: " + world);
+            } catch (Exception ignored) {
+                PS.log("Failed to reload world: " + world);
                 Bukkit.getServer().unloadWorld(world, false);
             }
         }
-        world = Bukkit.getWorld(worldname);
-        final ChunkGenerator gen = world.getGenerator();
+        world = Bukkit.getWorld(worldName);
+        ChunkGenerator gen = world.getGenerator();
         if (gen instanceof BukkitPlotGenerator) {
-            PS.get().loadWorld(worldname, (BukkitPlotGenerator) gen);
+            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);
-            }
+            PS.get().loadWorld(worldName, new BukkitPlotGenerator(worldName, gen));
+        } else if (PS.get().worlds.contains("worlds." + worldName)) {
+            PS.get().loadWorld(worldName, null);
         }
     }
-    
+
     @Override
     public SchematicHandler initSchematicHandler() {
         return new BukkitSchematicHandler();
     }
-    
+
     @Override
     public AbstractTitle initTitleManager() {
         // Already initialized in UUID handler
         return AbstractTitle.TITLE_CLASS;
     }
-    
+
     @Override
-    public PlotPlayer wrapPlayer(final Object obj) {
-        if (obj instanceof Player) {
-            return BukkitUtil.getPlayer((Player) obj);
-        } else if (obj instanceof OfflinePlayer) {
-            return BukkitUtil.getPlayer((OfflinePlayer) obj);
-        } else if (obj instanceof String) {
-            return UUIDHandler.getPlayer((String) obj);
-        } else if (obj instanceof UUID) {
-            return UUIDHandler.getPlayer((UUID) obj);
+    public PlotPlayer wrapPlayer(Object player) {
+        if (player instanceof Player) {
+            return BukkitUtil.getPlayer((Player) player);
+        }
+        if (player instanceof OfflinePlayer) {
+            return BukkitUtil.getPlayer((OfflinePlayer) player);
+        }
+        if (player instanceof String) {
+            return UUIDHandler.getPlayer((String) player);
+        }
+        if (player instanceof UUID) {
+            return UUIDHandler.getPlayer((UUID) player);
         }
         return null;
     }
-    
+
     @Override
     public String getNMSPackage() {
-        final Server server = Bukkit.getServer();
-        final Class<?> bukkitServerClass = server.getClass();
-        String[] pas = bukkitServerClass.getName().split("\\.");
-        if (pas.length == 5) {
-            return pas[3];
-        }
-        try {
-            final Method getHandle = bukkitServerClass.getDeclaredMethod("getHandle");
-            final Object handle = getHandle.invoke(server);
-            final Class handleServerClass = handle.getClass();
-            pas = handleServerClass.getName().split("\\.");
-            if (pas.length == 5) {
-                return pas[3];
-            }
-        } catch (IllegalAccessException | InvocationTargetException | SecurityException | NoSuchMethodException | IllegalArgumentException e) {
-            e.printStackTrace();
-        }
-        PS.debug("Unknown NMS package: " + StringMan.getString(pas));
-        return "1_8_R3";
+        String name = Bukkit.getServer().getClass().getPackage().getName();
+        return name.substring(name.lastIndexOf('.') + 1);
     }
-    
+
     @Override
     public ChatManager<?> initChatManager() {
-        if (Settings.FANCY_CHAT) {
+        if (Settings.Chat.INTERACTIVE) {
             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());
+            names.add(plugin.getName() + ';' + plugin.getDescription().getVersion() + ':' + plugin.isEnabled());
         }
         return names;
     }

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

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

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

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

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

@@ -5,7 +5,7 @@ import java.util.HashMap;
 import java.util.Map;
 
 import com.google.gson.stream.JsonWriter;
-import com.intellectualcrafters.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
 
 /**
  * Represents a JSON string value.
@@ -13,35 +13,35 @@ import com.intellectualcrafters.configuration.serialization.ConfigurationSeriali
  * All writes merely write the represented string value.
  */
 final class JsonString implements JsonRepresentedObject, ConfigurationSerializable {
-    
-    private final String _value;
-    
-    public JsonString(final CharSequence value) {
-        _value = value == null ? null : value.toString();
-    }
-    
-    @Override
-    public void writeJson(final JsonWriter writer) throws IOException {
-        writer.value(getValue());
-    }
-    
-    public String getValue() {
-        return _value;
-    }
-    
-    @Override
-    public Map<String, Object> serialize() {
-        final HashMap<String, Object> theSingleValue = new HashMap<String, Object>();
-        theSingleValue.put("stringValue", _value);
-        return theSingleValue;
-    }
-    
-    public static JsonString deserialize(final Map<String, Object> map) {
-        return new JsonString(map.get("stringValue").toString());
-    }
-    
-    @Override
-    public String toString() {
-        return _value;
-    }
+
+	private String _value;
+
+	public JsonString(CharSequence value) {
+		_value = value == null ? null : value.toString();
+	}
+
+	@Override
+	public void writeJson(JsonWriter writer) throws IOException {
+		writer.value(getValue());
+	}
+
+	public String getValue() {
+		return _value;
+	}
+
+	public Map<String, Object> serialize() {
+		HashMap<String, Object> theSingleValue = new HashMap<String, Object>();
+		theSingleValue.put("stringValue", _value);
+		return theSingleValue;
+	}
+
+	public static JsonString deserialize(Map<String, Object> map) {
+		return new JsonString(map.get("stringValue").toString());
+	}
+
+	@Override
+	public String toString() {
+		return _value;
+	}
+
 }

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

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

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

@@ -3,7 +3,6 @@ package com.plotsquared.bukkit.chat;
 import org.bukkit.Bukkit;
 
 import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -15,213 +14,205 @@ import java.util.Map;
  */
 public final class Reflection {
 
-    /**
-     * Stores loaded classes from the {@code net.minecraft.server} package.
-     */
-    private static final Map<String, Class<?>> _loadedNMSClasses = new HashMap<>();
-    /**
-     * Stores loaded classes from the {@code org.bukkit.craftbukkit} package (and subpackages).
-     */
-    private static final Map<String, Class<?>> _loadedOBCClasses = new HashMap<>();
-    private static final Map<Class<?>, Map<String, Field>> _loadedFields = new HashMap<>();
-    /**
-     * Contains loaded methods in a cache.
-     * The map maps [types to maps of [method names to maps of [parameter types to method instances]]].
-     */
-    private static final Map<Class<?>, Map<String, Map<ArrayWrapper<Class<?>>, Method>>> _loadedMethods = new HashMap<>();
-    private static String _versionString;
+	private static String _versionString;
 
-    private Reflection() {
+	private Reflection() { }
 
-    }
-    
-    /**
-     * Gets the version string from the package name of the CraftBukkit server implementation.
-     * This is needed to bypass the JAR package name changing on each update.
-     * @return The version string of the OBC and NMS packages, <em>including the trailing dot</em>.
-     */
-    public synchronized static String getVersion() {
-        if (_versionString == null) {
-            if (Bukkit.getServer() == null) {
-                // The server hasn't started, static initializer call?
-                return null;
-            }
-            final String name = Bukkit.getServer().getClass().getPackage().getName();
-            _versionString = name.substring(name.lastIndexOf('.') + 1) + ".";
-        }
+	/**
+	 * Gets the version string from the package name of the CraftBukkit server implementation.
+	 * This is needed to bypass the JAR package name changing on each update.
+	 *
+	 * @return The version string of the OBC and NMS packages, <em>including the trailing dot</em>.
+	 */
+	public synchronized static String getVersion() {
+		if (_versionString == null) {
+			if (Bukkit.getServer() == null) {
+				// The server hasn't started, static initializer call?
+				return null;
+			}
+			String name = Bukkit.getServer().getClass().getPackage().getName();
+			_versionString = name.substring(name.lastIndexOf('.') + 1) + ".";
+		}
 
-        return _versionString;
-    }
-    
-    /**
-     * Gets a {@link Class} object representing a type contained within the {@code net.minecraft.server} versioned package.
-     * The class instances returned by this method are cached, such that no lookup will be done twice (unless multiple threads are accessing this method simultaneously).
-     * @param className The name of the class, excluding the package, within NMS.
-     * @return The class instance representing the specified NMS class, or {@code null} if it could not be loaded.
-     */
-    public synchronized static Class<?> getNMSClass(final String className) {
-        if (_loadedNMSClasses.containsKey(className)) {
-            return _loadedNMSClasses.get(className);
-        }
+		return _versionString;
+	}
 
-        final 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 synchronized static Class<?> getOBCClass(final String className) {
-        if (_loadedOBCClasses.containsKey(className)) {
-            return _loadedOBCClasses.get(className);
-        }
+	/**
+	 * Stores loaded classes from the {@code net.minecraft.server} package.
+	 */
+	private static final Map<String, Class<?>> _loadedNMSClasses = new HashMap<String, Class<?>>();
+
+	/**
+	 * Stores loaded classes from the {@code org.bukkit.craftbukkit} package (and subpackages).
+	 */
+	private static final Map<String, Class<?>> _loadedOBCClasses = new HashMap<String, Class<?>>();
+
+	/**
+	 * Gets a {@link Class} object representing a type contained within the {@code net.minecraft.server} versioned package.
+	 * The class instances returned by this method are cached, such that no lookup will be done twice (unless multiple threads are accessing this method simultaneously).
+	 *
+	 * @param className The name of the class, excluding the package, within NMS.
+	 * @return The class instance representing the specified NMS class, or {@code null} if it could not be loaded.
+	 */
+	public synchronized static Class<?> getNMSClass(String className) {
+		if (_loadedNMSClasses.containsKey(className)) {
+			return _loadedNMSClasses.get(className);
+		}
+
+		String fullName = "net.minecraft.server." + getVersion() + className;
+		Class<?> clazz = null;
+		try {
+			clazz = Class.forName(fullName);
+		} catch (Exception 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 synchronized static Class<?> getOBCClass(String className) {
+		if (_loadedOBCClasses.containsKey(className)) {
+			return _loadedOBCClasses.get(className);
+		}
+
+		String fullName = "org.bukkit.craftbukkit." + getVersion() + className;
+		Class<?> clazz = null;
+		try {
+			clazz = Class.forName(fullName);
+		} catch (Exception 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 synchronized static Object getHandle(Object obj) {
+		try {
+			return getMethod(obj.getClass(), "getHandle").invoke(obj);
+		} catch (Exception e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+
+	private static final Map<Class<?>, Map<String, Field>> _loadedFields = new HashMap<Class<?>, Map<String, Field>>();
+
+	/**
+	 * Retrieves a {@link Field} instance declared by the specified class with the specified name.
+	 * Java access modifiers are ignored during this retrieval. No guarantee is made as to whether the field
+	 * returned will be an instance or static field.
+	 * <p>
+	 * A global caching mechanism within this class is used to store fields. Combined with synchronization, this guarantees that
+	 * no field will be reflectively looked up twice.
+	 * </p>
+	 * <p>
+	 * If a field is deemed suitable for return, {@link Field#setAccessible(boolean) setAccessible} will be invoked with an argument of {@code true} before it is returned.
+	 * This ensures that callers do not have to check or worry about Java access modifiers when dealing with the returned instance.
+	 * </p>
+	 *
+	 * @param clazz The class which contains the field to retrieve.
+	 * @param name  The declared name of the field in the class.
+	 * @return A field object with the specified name declared by the specified class.
+	 * @see Class#getDeclaredField(String)
+	 */
+	public synchronized static Field getField(Class<?> clazz, String name) {
+		Map<String, Field> loaded;
+		if (!_loadedFields.containsKey(clazz)) {
+			loaded = new HashMap<String, Field>();
+			_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 (Exception e) {
+			// Error loading
+			e.printStackTrace();
+			// Cache field as not existing
+			loaded.put(name, null);
+			return null;
+		}
+	}
+
+	/**
+	 * 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<Class<?>, Map<String, Map<ArrayWrapper<Class<?>>, Method>>>();
+
+	/**
+	 * 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 synchronized static 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<Class<?>>(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;
+	}
 
-        final 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 synchronized static Object getHandle(final Object obj) {
-        try {
-            return getMethod(obj.getClass(), "getHandle").invoke(obj);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-            return null;
-        } catch (IllegalArgumentException e) {
-            e.printStackTrace();
-            return null;
-        } catch (InvocationTargetException e) {
-            e.printStackTrace();
-            return null;
-        }
-    }
-    
-    /**
-     * Retrieves a {@link Field} instance declared by the specified class with the specified name.
-     * Java access modifiers are ignored during this retrieval. No guarantee is made as to whether the field
-     * returned will be an instance or static field.
-     * <p>
-     * A global caching mechanism within this class is used to store fields. Combined with synchronization, this guarantees that
-     * no field will be reflectively looked up twice.
-     * </p>
-     * <p>
-     * If a field is deemed suitable for return,
-     * {@link Field#setAccessible(boolean) setAccessible} will be invoked with an argument of {@code true} before it is returned.
-     * This ensures that callers do not have to check or worry about Java access modifiers when dealing with the returned instance.
-     * </p>
-     * @param clazz The class which contains the field to retrieve.
-     * @param name The declared name of the field in the class.
-     * @return A field object with the specified name declared by the specified class.
-     * @see Class#getDeclaredField(String)
-     */
-    public synchronized static Field getField(final Class<?> clazz, final 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 {
-            final Field field = clazz.getDeclaredField(name);
-            field.setAccessible(true);
-            loaded.put(name, field);
-            return field;
-        } catch (NoSuchFieldException e) {
-            // Error loading
-            e.printStackTrace();
-            // Cache field as not existing
-            loaded.put(name, null);
-            return null;
-        } catch (SecurityException e) {
-            // 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 synchronized static Method getMethod(final Class<?> clazz, final String name, final Class<?>... args) {
-        if (!_loadedMethods.containsKey(clazz)) {
-            _loadedMethods.put(clazz, new HashMap<String, Map<ArrayWrapper<Class<?>>, Method>>());
-        }
-        
-        final Map<String, Map<ArrayWrapper<Class<?>>, Method>> loadedMethodNames = _loadedMethods.get(clazz);
-        if (!loadedMethodNames.containsKey(name)) {
-            loadedMethodNames.put(name, new HashMap<ArrayWrapper<Class<?>>, Method>());
-        }
-        
-        final Map<ArrayWrapper<Class<?>>, Method> loadedSignatures = loadedMethodNames.get(name);
-        final ArrayWrapper<Class<?>> wrappedArg = new ArrayWrapper<>(args);
-        if (loadedSignatures.containsKey(wrappedArg)) {
-            return loadedSignatures.get(wrappedArg);
-        }
-        
-        for (final 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

@@ -3,8 +3,8 @@ 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 org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
 
 import java.io.IOException;
 import java.util.HashMap;
@@ -18,276 +18,280 @@ import java.util.Map;
  */
 public abstract class TextualComponent implements Cloneable {
 
-    static {
-        ConfigurationSerialization.registerClass(TextualComponent.ArbitraryTextTypeComponent.class);
-        ConfigurationSerialization.registerClass(TextualComponent.ComplexTextTypeComponent.class);
-    }
+	static {
+		ConfigurationSerialization.registerClass(TextualComponent.ArbitraryTextTypeComponent.class);
+		ConfigurationSerialization.registerClass(TextualComponent.ComplexTextTypeComponent.class);
+	}
 
-    @Override
-    public String toString() {
-        return getReadableString();
-    }
+	@Override
+	public String toString() {
+		return getReadableString();
+	}
 
-    /**
-     * @return The JSON key used to represent text components of this type.
-     */
-    public abstract String getKey();
+	/**
+	 * @return The JSON key used to represent text components of this type.
+	 */
+	public abstract String getKey();
 
-    /**
-     * @return A readable String
-     */
-    public abstract String getReadableString();
+	/**
+	 * @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;
+	/**
+	 * 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(final JsonWriter writer) throws IOException;
+	/**
+	 * 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;
 
-    static TextualComponent deserialize(final Map<String, Object> map) {
-        if (map.containsKey("key") && (map.size() == 2) && map.containsKey("value")) {
-            // Arbitrary text component
-            return ArbitraryTextTypeComponent.deserialize(map);
-        } else if ((map.size() >= 2) && map.containsKey("key") && !map.containsKey("value") /* It contains keys that START WITH value */) {
-            // Complex JSON object
-            return ComplexTextTypeComponent.deserialize(map);
-        }
+	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;
-    }
+		return null;
+	}
 
-    static boolean isTextKey(final String key) {
-        return key.equals("translate") || key.equals("text") || key.equals("score") || key.equals("selector");
-    }
+	static boolean isTextKey(String key) {
+		return key.equals("translate") || key.equals("text") || key.equals("score") || key.equals("selector");
+	}
 
-    static boolean isTranslatableText(final TextualComponent component) {
-        return (component instanceof ComplexTextTypeComponent) && ((ComplexTextTypeComponent) component).getKey().equals("translate");
-    }
+	static boolean isTranslatableText(TextualComponent component) {
+		return component instanceof ComplexTextTypeComponent && ((ComplexTextTypeComponent) component).getKey().equals("translate");
+	}
 
-    /**
-     * 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 {
+	/**
+	 * 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 {
 
-        public ArbitraryTextTypeComponent(final String key, final String value) {
-            setKey(key);
-            setValue(value);
-        }
+		public ArbitraryTextTypeComponent(String key, String value) {
+			setKey(key);
+			setValue(value);
+		}
 
-        @Override
-        public String getKey() {
-            return _key;
-        }
+		@Override
+		public String getKey() {
+			return _key;
+		}
 
-        public void setKey(final String key) {
-            Preconditions.checkArgument((key != null) && !key.isEmpty(), "The key must be specified.");
-            _key = key;
-        }
+		public void setKey(String key) {
+			Preconditions.checkArgument(key != null && !key.isEmpty(), "The key must be specified.");
+			_key = key;
+		}
 
-        public String getValue() {
-            return _value;
-        }
+		public String getValue() {
+			return _value;
+		}
 
-        public void setValue(final String value) {
-            Preconditions.checkArgument(value != null, "The value must be specified.");
-            _value = value;
-        }
+		public void setValue(String value) {
+			Preconditions.checkArgument(value != null, "The value must be specified.");
+			_value = value;
+		}
 
-        private String _key;
-        private String _value;
+		private String _key;
+		private String _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 TextualComponent clone() throws CloneNotSupportedException {
+			// Since this is a private and final class, we can just reinstantiate this class instead of casting super.clone
+			return new ArbitraryTextTypeComponent(getKey(), getValue());
+		}
 
-        @Override
-        public void writeJson(final JsonWriter writer) throws IOException {
-            writer.name(getKey()).value(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());
-                }
-            };
-        }
+		@SuppressWarnings("serial")
+		public Map<String, Object> serialize() {
+			return new HashMap<String, Object>() {{
+				put("key", getKey());
+				put("value", getValue());
+			}};
+		}
 
-        public static ArbitraryTextTypeComponent deserialize(final Map<String, Object> map) {
-            return new ArbitraryTextTypeComponent(map.get("key").toString(), map.get("value").toString());
-        }
+		public static ArbitraryTextTypeComponent deserialize(Map<String, Object> map) {
+			return new ArbitraryTextTypeComponent(map.get("key").toString(), map.get("value").toString());
+		}
 
-        @Override
-        public String getReadableString() {
-            return 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 {
+	/**
+	 * Internal class used to represent a text component with a nested JSON value.
+	 * Exception validating done is on keys and values.
+	 */
+	private static final class ComplexTextTypeComponent extends TextualComponent implements ConfigurationSerializable {
 
-        public ComplexTextTypeComponent(final String key, final Map<String, String> values) {
-            setKey(key);
-            setValue(values);
-        }
+		public ComplexTextTypeComponent(String key, Map<String, String> values) {
+			setKey(key);
+			setValue(values);
+		}
 
-        @Override
-        public String getKey() {
-            return _key;
-        }
+		@Override
+		public String getKey() {
+			return _key;
+		}
 
-        public void setKey(final String key) {
-            Preconditions.checkArgument((key != null) && !key.isEmpty(), "The key must be specified.");
-            _key = key;
-        }
+		public void setKey(String key) {
+			Preconditions.checkArgument(key != null && !key.isEmpty(), "The key must be specified.");
+			_key = key;
+		}
 
-        public Map<String, String> getValue() {
-            return _value;
-        }
+		public Map<String, String> getValue() {
+			return _value;
+		}
 
-        public void setValue(final Map<String, String> value) {
-            Preconditions.checkArgument(value != null, "The value must be specified.");
-            _value = value;
-        }
+		public void setValue(Map<String, String> value) {
+			Preconditions.checkArgument(value != null, "The value must be specified.");
+			_value = value;
+		}
 
-        private String _key;
-        private Map<String, String> _value;
+		private String _key;
+		private Map<String, String> _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 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(final JsonWriter writer) throws IOException {
-            writer.name(getKey());
-            writer.beginObject();
-            for (final Map.Entry<String, String> jsonPair : _value.entrySet()) {
-                writer.name(jsonPair.getKey()).value(jsonPair.getValue());
-            }
-            writer.endObject();
-        }
+		@Override
+		public void writeJson(JsonWriter writer) throws IOException {
+			writer.name(getKey());
+			writer.beginObject();
+			for (Map.Entry<String, String> jsonPair : _value.entrySet()) {
+				writer.name(jsonPair.getKey()).value(jsonPair.getValue());
+			}
+			writer.endObject();
+		}
 
-        @Override
-        @SuppressWarnings("serial")
-        public Map<String, Object> serialize() {
-            return new java.util.HashMap<String, Object>() {
-                {
-                    put("key", getKey());
-                    for (final Map.Entry<String, String> valEntry : getValue().entrySet()) {
-                        put("value." + valEntry.getKey(), valEntry.getValue());
-                    }
-                }
-            };
-        }
+		@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());
+				}
+			}};
+		}
 
-        public static ComplexTextTypeComponent deserialize(final Map<String, Object> map) {
-            String key = null;
-            final Map<String, String> value = new HashMap<String, String>();
-            for (final Map.Entry<String, Object> valEntry : map.entrySet()) {
-                if (valEntry.getKey().equals("key")) {
-                    key = (String) valEntry.getValue();
-                } else if (valEntry.getKey().startsWith("value.")) {
-                    value.put(valEntry.getKey().substring(6) /* Strips out the value prefix */, valEntry.getValue().toString());
-                }
-            }
-            return new ComplexTextTypeComponent(key, value);
-        }
+		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(((String) valEntry.getKey()).substring(6) /* Strips out the value prefix */, valEntry.getValue().toString());
+				}
+			}
+			return new ComplexTextTypeComponent(key, value);
+		}
 
-        @Override
-        public String getReadableString() {
-            return getKey();
-        }
-    }
+		@Override
+		public String getReadableString() {
+			return getKey();
+		}
+	}
 
-    /**
-     * Create a textual component representing a string literal.
-     * This is the default type of textual component when a single string literal is given to a method.
-     * @param textValue The text which will be represented.
-     * @return The text component representing the specified literal text.
-     */
-    public static TextualComponent rawText(final String textValue) {
-        return new ArbitraryTextTypeComponent("text", textValue);
-    }
+	/**
+	 * Create a textual component representing a 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(final String translateKey) {
-        return new ArbitraryTextTypeComponent("translate", translateKey);
-    }
 
-    private static void throwUnsupportedSnapshot() {
-        throw new UnsupportedOperationException("This feature is only supported in snapshot releases.");
-    }
+	/**
+	 * Create a textual component representing a 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);
+	}
 
-    /**
-     * Create a textual component representing a scoreboard value.
-     * The client will see their own score for the specified objective as the text represented by this component.
-     * <p>
-     * <b>This method is currently guaranteed to throw an {@code UnsupportedOperationException} as it is only supported on snapshot clients.</b>
-     * </p>
-     * @param scoreboardObjective The name of the objective for which to display the score.
-     * @return The text component representing the specified scoreboard score (for the viewing player), or {@code null} if an error occurs during JSON serialization.
-     */
-    public static TextualComponent objectiveScore(final String scoreboardObjective) {
-        return objectiveScore("*", scoreboardObjective);
-    }
+	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 the score of the specified player for the specified objective as the text represented by this component.
-     * <p>
-     * <b>This method is currently guaranteed to throw an {@code UnsupportedOperationException} as it is only supported on snapshot clients.</b>
-     * </p>
-     * @param playerName The name of the player whos score will be shown. If this string represents the single-character sequence "*", the viewing player's score will be displayed.
-     * Standard minecraft selectors (@a, @p, etc) are <em>not</em> supported.
-     * @param scoreboardObjective The name of the objective for which to display the score.
-     * @return The text component representing the specified scoreboard score for the specified player, or {@code null} if an error occurs during JSON serialization.
-     */
-    public static TextualComponent objectiveScore(final String playerName, final String scoreboardObjective) {
-        throwUnsupportedSnapshot(); // Remove this line when the feature is released to non-snapshot versions, in addition to updating ALL THE OVERLOADS documentation accordingly
+	/**
+	 * 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);
+	}
 
-        return new ComplexTextTypeComponent("score", ImmutableMap.<String, String> builder().put("name", playerName).put("objective", scoreboardObjective).build());
-    }
+	/**
+	 * 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
 
-    /**
-     * Create a textual component representing a player name, retrievable by using a standard minecraft selector.
-     * The client will see the players or entities captured by the specified selector as the text represented by this component.
-     * <p>
-     * <b>This method is currently guaranteed to throw an {@code UnsupportedOperationException} as it is only supported on snapshot clients.</b>
-     * </p>
-     * @param selector The minecraft player or entity selector which will capture the entities whose string representations will be displayed in the place of this text component.
-     * @return The text component representing the name of the entities captured by the selector.
-     */
-    public static TextualComponent selector(final String selector) {
-        throwUnsupportedSnapshot(); // Remove this line when the feature is released to non-snapshot versions, in addition to updating ALL THE OVERLOADS documentation accordingly
-        
-        return new ArbitraryTextTypeComponent("selector", selector);
-    }
+		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);
+	}
 }

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

@@ -1,31 +1,11 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// PlotSquared - A plot manager and world generator for the Bukkit API                             /
-// Copyright (c) 2014 IntellectualSites/IntellectualCrafters                                       /
-//                                                                                                 /
-// This program is free software; you can redistribute it and/or modify                            /
-// it under the terms of the GNU General Public License as published by                            /
-// the Free Software Foundation; either version 3 of the License, or                               /
-// (at your option) any later version.                                                             /
-//                                                                                                 /
-// This program is distributed in the hope that it will be useful,                                 /
-// but WITHOUT ANY WARRANTY; without even the implied warranty of                                  /
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                   /
-// GNU General Public License for more details.                                                    /
-//                                                                                                 /
-// You should have received a copy of the GNU General Public License                               /
-// along with this program; if not, write to the Free Software Foundation,                         /
-// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA                               /
-//                                                                                                 /
-// You can contact us via: support@intellectualsites.com                                           /
-////////////////////////////////////////////////////////////////////////////////////////////////////
 package com.plotsquared.bukkit.commands;
 
+import com.google.common.collect.Sets;
 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;
@@ -37,14 +17,13 @@ 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.DatFileFilter;
 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;
@@ -56,23 +35,23 @@ 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)
+        command = "uuidconvert",
+        permission = "plots.admin",
+        description = "Debug UUID conversion",
+        usage = "/plot uuidconvert <lower|offline|online>",
+        requiredType = RequiredType.CONSOLE,
+        category = CommandCategory.DEBUG)
 public class DebugUUID extends SubCommand {
-    
+
     public DebugUUID() {
-        requiredArguments = new Argument[] { Argument.String };
+        super(Argument.String);
     }
-    
+
     @Override
-    public boolean onCommand(final PlotPlayer player, final String[] args) {
+    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();
@@ -85,9 +64,9 @@ public class DebugUUID extends SubCommand {
                 break;
             default:
                 try {
-                    final Class<?> clazz = Class.forName(args[0]);
+                    Class<?> clazz = Class.forName(args[0]);
                     newWrapper = (UUIDWrapper) clazz.newInstance();
-                } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
+                } catch (ClassNotFoundException | IllegalAccessException | InstantiationException ignored) {
                     MainUtil.sendMessage(player, C.COMMAND_SYNTAX, "/plot uuidconvert <lower|offline|online>");
                     return false;
                 }
@@ -104,7 +83,7 @@ public class DebugUUID extends SubCommand {
             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;
@@ -114,69 +93,58 @@ public class DebugUUID extends SubCommand {
         for (Entry<String, PlotPlayer> entry : UUIDHandler.getPlayers().entrySet()) {
             entry.getValue().kick("PlotSquared UUID conversion has been initiated. You may reconnect when finished.");
         }
-        
+
         MainUtil.sendMessage(player, "&7 - Initializing map");
 
         final HashMap<UUID, UUID> uCMap = new HashMap<>();
         final HashMap<UUID, UUID> uCReverse = new HashMap<>();
-        
+
         MainUtil.sendMessage(player, "&7 - Collecting playerdata");
-        
-        final HashSet<String> worlds = new HashSet<>();
-        worlds.add(WorldUtil.IMP.getMainWorld());
-        worlds.add("world");
-        final HashSet<UUID> uuids = new HashSet<>();
-        final HashSet<String> names = new HashSet<>();
-        for (final String worldname : worlds) {
-            final File playerdataFolder = new File(worldname + File.separator + "playerdata");
-            String[] dat = playerdataFolder.list(new FilenameFilter() {
-                @Override
-                public boolean accept(final File f, final String s) {
-                    return s.endsWith(".dat");
-                }
-            });
-            if (dat != null)
-                for (final String current : dat) {
-                    final String s = current.replaceAll(".dat$", "");
+
+        HashSet<String> worlds = Sets.newHashSet(WorldUtil.IMP.getMainWorld(), "world");
+        HashSet<UUID> uuids = new HashSet<>();
+        HashSet<String> names = new HashSet<>();
+        for (String worldName : worlds) {
+            File playerDataFolder = new File(worldName + File.separator + "playerdata");
+            String[] dat = playerDataFolder.list(new DatFileFilter());
+            if (dat != null) {
+                for (String current : dat) {
+                    String s = current.replaceAll(".dat$", "");
                     try {
-                        final UUID uuid = UUID.fromString(s);
+                        UUID uuid = UUID.fromString(s);
                         uuids.add(uuid);
-                    } catch (final Exception e) {
-                        MainUtil.sendMessage(player, C.PREFIX.s() + "Invalid playerdata: " + current);
+                    } catch (Exception ignored) {
+                        MainUtil.sendMessage(player, C.PREFIX + "Invalid playerdata: " + current);
                     }
                 }
-            final File playersFolder = new File(worldname + File.separator + "players");
-            dat = playersFolder.list(new FilenameFilter() {
-                @Override
-                public boolean accept(final File f, final String s) {
-                    return s.endsWith(".dat");
-                }
-            });
+            }
+            File playersFolder = new File(worldName + File.separator + "players");
+            dat = playersFolder.list(new DatFileFilter());
             if (dat != null) {
-                for (final String current : dat) {
+                for (String current : dat) {
                     names.add(current.replaceAll(".dat$", ""));
                 }
             }
         }
-        
+
         MainUtil.sendMessage(player, "&7 - Populating map");
         UUID uuid2;
-        final UUIDWrapper wrapper = new DefaultUUIDWrapper();
+        UUIDWrapper wrapper = new DefaultUUIDWrapper();
         for (UUID uuid : uuids) {
             try {
-                final OfflinePlotPlayer op = wrapper.getOfflinePlayer(uuid);
+                OfflinePlotPlayer op = wrapper.getOfflinePlayer(uuid);
                 uuid = currentUUIDWrapper.getUUID(op);
                 uuid2 = newWrapper.getUUID(op);
                 if (!uuid.equals(uuid2) && !uCMap.containsKey(uuid) && !uCReverse.containsKey(uuid2)) {
                     uCMap.put(uuid, uuid2);
                     uCReverse.put(uuid2, uuid);
                 }
-            } catch (final Throwable e) {
-                MainUtil.sendMessage(player, C.PREFIX.s() + "&6Invalid playerdata: " + uuid.toString() + ".dat");
+            } catch (Throwable ignored) {
+                MainUtil.sendMessage(player, C.PREFIX + "&6Invalid playerdata: " + uuid.toString() + ".dat");
             }
         }
-        for (final String name : names) {
-            final UUID uuid = currentUUIDWrapper.getUUID(name);
+        for (String name : names) {
+            UUID uuid = currentUUIDWrapper.getUUID(name);
             uuid2 = newWrapper.getUUID(name);
             if (!uuid.equals(uuid2)) {
                 uCMap.put(uuid, uuid2);
@@ -185,11 +153,11 @@ public class DebugUUID extends SubCommand {
         }
         if (uCMap.isEmpty()) {
             MainUtil.sendMessage(player, "&c - Error! Attempting to repopulate");
-            for (final OfflinePlotPlayer op : currentUUIDWrapper.getOfflinePlayers()) {
+            for (OfflinePlotPlayer op : currentUUIDWrapper.getOfflinePlayers()) {
                 if (op.getLastPlayed() != 0) {
                     //                    String name = op.getName();
                     //                    StringWrapper wrap = new StringWrapper(name);
-                    final UUID uuid = currentUUIDWrapper.getUUID(op);
+                    UUID uuid = currentUUIDWrapper.getUUID(op);
                     uuid2 = newWrapper.getUUID(op);
                     if (!uuid.equals(uuid2)) {
                         uCMap.put(uuid, uuid2);
@@ -204,24 +172,24 @@ public class DebugUUID extends SubCommand {
                 MainUtil.sendMessage(player, "&a - Successfully repopulated");
             }
         }
-        
+
         MainUtil.sendMessage(player, "&7 - Replacing cache");
         TaskManager.runTaskAsync(new Runnable() {
             @Override
             public void run() {
-                for (final Entry<UUID, UUID> entry : uCMap.entrySet()) {
-                    final String name = UUIDHandler.getName(entry.getKey());
+                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)");
-                
-                final File file = new File(PS.get().IMP.getDirectory(), "uuids.txt");
+
+                File file = new File(PS.get().IMP.getDirectory(), "uuids.txt");
                 if (file.exists()) {
                     try {
-                        final List<String> lines = Files.readAllLines(file.toPath(), StandardCharsets.UTF_8);
+                        List<String> lines = Files.readAllLines(file.toPath(), StandardCharsets.UTF_8);
                         for (String line : lines) {
                             try {
                                 line = line.trim();
@@ -229,35 +197,35 @@ public class DebugUUID extends SubCommand {
                                     continue;
                                 }
                                 line = line.replaceAll("[\\|][0-9]+[\\|][0-9]+[\\|]", "");
-                                final String[] split = line.split("\\|");
-                                final String name = split[0];
+                                String[] split = line.split("\\|");
+                                String name = split[0];
                                 if (name.isEmpty() || name.length() > 16 || !StringMan.isAlphanumericUnd(name)) {
                                     continue;
                                 }
-                                final UUID old = currentUUIDWrapper.getUUID(name);
+                                UUID old = currentUUIDWrapper.getUUID(name);
                                 if (old == null) {
                                     continue;
                                 }
-                                final UUID now = newWrapper.getUUID(name);
+                                UUID now = newWrapper.getUUID(name);
                                 UUIDHandler.add(new StringWrapper(name), now);
                                 uCMap.put(old, now);
                                 uCReverse.put(now, old);
-                            } catch (final Exception e2) {
+                            } catch (Exception e2) {
                                 e2.printStackTrace();
                             }
                         }
-                    } catch (final IOException e) {
+                    } catch (IOException e) {
                         e.printStackTrace();
                     }
                 }
-                
+
                 MainUtil.sendMessage(player, "&7 - Replacing wrapper");
                 UUIDHandler.setUUIDWrapper(newWrapper);
-                
+
                 MainUtil.sendMessage(player, "&7 - Updating plot objects");
-                
-                for (final Plot plot : PS.get().getPlots()) {
-                    final UUID value = uCMap.get(plot.owner);
+
+                for (Plot plot : PS.get().getPlots()) {
+                    UUID value = uCMap.get(plot.owner);
                     if (value != null) {
                         plot.owner = value;
                     }
@@ -265,24 +233,23 @@ public class DebugUUID extends SubCommand {
                     plot.getMembers().clear();
                     plot.getDenied().clear();
                 }
-                
+
                 MainUtil.sendMessage(player, "&7 - Deleting database");
-                final AbstractDB database = DBFunc.dbManager;
-                final boolean result = database.deleteTables();
-                
+                boolean result = DBFunc.deleteTables();
+
                 MainUtil.sendMessage(player, "&7 - Creating tables");
-                
+
                 try {
-                    database.createTables();
+                    DBFunc.createTables();
                     if (!result) {
                         MainUtil.sendMessage(player, "&cConversion failed! Attempting recovery");
-                        for (final Plot plot : PS.get().getPlots()) {
-                            final UUID value = uCReverse.get(plot.owner);
+                        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() {
+                        DBFunc.createPlotsAndData(new ArrayList<>(PS.get().getPlots()), new Runnable() {
                             @Override
                             public void run() {
                                 MainUtil.sendMessage(player, "&6Recovery was successful!");
@@ -290,31 +257,31 @@ public class DebugUUID extends SubCommand {
                         });
                         return;
                     }
-                } catch (final Exception e) {
+                } 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);
+                    PS.get().worlds.set("UUID.force-lowercase", false);
+                    PS.get().worlds.set("UUID.offline", true);
                 } else if (newWrapper instanceof DefaultUUIDWrapper) {
-                    PS.get().config.set("UUID.force-lowercase", false);
-                    PS.get().config.set("UUID.offline", false);
+                    PS.get().worlds.set("UUID.force-lowercase", false);
+                    PS.get().worlds.set("UUID.offline", false);
                 }
                 try {
-                    PS.get().config.save(PS.get().configFile);
-                } catch (IOException e) {
-                    MainUtil.sendMessage(player, "Could not save configuration. It will need to be manuall set!");
+                    PS.get().worlds.save(PS.get().worldsFile);
+                } catch (IOException ignored) {
+                    MainUtil.sendMessage(player, "Could not save configuration. It will need to be manual set!");
                 }
-                
+
                 MainUtil.sendMessage(player, "&7 - Populating tables");
-                
+
                 TaskManager.runTaskAsync(new Runnable() {
                     @Override
                     public void run() {
-                        final ArrayList<Plot> plots = new ArrayList<>(PS.get().getPlots());
-                        database.createPlotsAndData(plots, new Runnable() {
+                        ArrayList<Plot> plots = new ArrayList<>(PS.get().getPlots());
+                        DBFunc.createPlotsAndData(plots, new Runnable() {
                             @Override
                             public void run() {
                                 MainUtil.sendMessage(player, "&aConversion complete!");
@@ -322,7 +289,7 @@ public class DebugUUID extends SubCommand {
                         });
                     }
                 });
-                
+
                 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");
             }

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

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

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

@@ -25,73 +25,70 @@ import java.util.Map.Entry;
 import java.util.UUID;
 
 public class ClassicPlotMeConnector extends APlotMeConnector {
-    
+
     private String plugin;
     private String prefix;
-    
+
     @Override
-    public Connection getPlotMeConnection(final String plugin, final FileConfiguration plotConfig, final String dataFolder) {
-        this.plugin = plugin.toLowerCase();
-        prefix = plotConfig.getString("mySQLprefix");
-        if (prefix == null) {
-            prefix = plugin.toLowerCase();
-        }
+    public Connection getPlotMeConnection(FileConfiguration plotConfig, String dataFolder) {
+        this.plugin = this.plugin.toLowerCase();
+        this.prefix = plotConfig.getString("mySQLprefix", this.plugin.toLowerCase());
         try {
             if (plotConfig.getBoolean("usemySQL")) {
-                final String user = plotConfig.getString("mySQLuname");
-                final String password = plotConfig.getString("mySQLpass");
-                final String con = plotConfig.getString("mySQLconn");
+                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();
+                return new SQLite(new File(dataFolder + File.separator + "plots.db")).openConnection();
             }
-        } catch (SQLException | ClassNotFoundException ignored) {
+        } catch (SQLException | ClassNotFoundException e) {
+            e.printStackTrace();
         }
         return null;
     }
-    
+
     @Override
-    public HashMap<String, HashMap<PlotId, Plot>> getPlotMePlots(final Connection connection) throws SQLException {
-        final HashMap<String, Integer> plotWidth = new HashMap<>();
-        final HashMap<String, Integer> roadWidth = new HashMap<>();
-        final HashMap<String, HashMap<PlotId, Plot>> plots = new HashMap<>();
-        final HashMap<String, HashMap<PlotId, boolean[]>> merges = new HashMap<>();
-        PreparedStatement stmt = connection.prepareStatement("SELECT * FROM `" + prefix + "Plots`");
-        ResultSet r = stmt.executeQuery();
+    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;
-        final boolean checkUUID = DBFunc.hasColumn(r, "ownerid");
-        final boolean checkUUID2 = DBFunc.hasColumn(r, "ownerId");
+        boolean checkUUID = DBFunc.hasColumn(resultSet, "ownerid");
+        boolean checkUUID2 = DBFunc.hasColumn(resultSet, "ownerId");
         if (checkUUID) {
             column = "ownerid";
         } else if (checkUUID2) {
             column = "ownerId";
         }
-        final boolean merge = !"plotme".equalsIgnoreCase(plugin) && Settings.CONVERT_PLOTME;
+        boolean merge = !"plotme".equalsIgnoreCase(this.plugin) && Settings.Enabled_Components.PLOTME_CONVERTER;
         int missing = 0;
-        while (r.next()) {
-            final PlotId id = new PlotId(r.getInt("idX"), r.getInt("idZ"));
-            final String name = r.getString("owner");
-            final String world = LikePlotMeConverter.getWorld(r.getString("world"));
+        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) {
-                    final int plot = PS.get().config.getInt("worlds." + world + ".plot.size");
-                    final int path = PS.get().config.getInt("worlds." + world + ".road.width");
+                    int plot = PS.get().worlds.getInt("worlds." + world + ".plot.size");
+                    int path = PS.get().worlds.getInt("worlds." + world + ".road.width");
                     plotWidth.put(world, plot);
                     roadWidth.put(world, path);
                     merges.put(world, new HashMap<PlotId, boolean[]>());
                 }
             }
             if (merge) {
-                final int tx = r.getInt("topX");
-                final int tz = r.getInt("topZ");
-                final int bx = r.getInt("bottomX") - 1;
-                final int bz = r.getInt("bottomZ") - 1;
-                final int path = roadWidth.get(world);
-                final int plot = plotWidth.get(world);
-                final Location top = getPlotTopLocAbs(path, plot, id);
-                final Location bot = getPlotBottomLocAbs(path, plot, id);
+                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);
                 }
@@ -111,93 +108,72 @@ public class ClassicPlotMeConnector extends APlotMeConnector {
                     owner = DBFunc.everyone;
                 } else {
                     if (checkUUID || checkUUID2) {
-                        try {
-                            final byte[] bytes = r.getBytes(column);
-                            if (bytes != null) {
-                                try {
-                                    final ByteBuffer bb = ByteBuffer.wrap(bytes);
-                                    final long high = bb.getLong();
-                                    final long low = bb.getLong();
-                                    owner = new UUID(high, low);
-                                } catch (final Exception e) {
-                                    e.printStackTrace();
-                                    owner = UUID.nameUUIDFromBytes(bytes);
-                                }
-                                UUIDHandler.add(new StringWrapper(name), owner);
-                            }
-                        } catch (SQLException e) {
-                            e.printStackTrace();
+                        byte[] bytes = resultSet.getBytes(column);
+                        if (bytes != null) {
+                            ByteBuffer bb = ByteBuffer.wrap(bytes);
+                            long high = bb.getLong();
+                            long low = bb.getLong();
+                            owner = new UUID(high, low);
+                            UUIDHandler.add(new StringWrapper(name), owner);
                         }
                     }
-                    if (owner == null) {
-                        if (!name.isEmpty()) {
-                            owner = UUID.nameUUIDFromBytes(("OfflinePlayer:" + name.toLowerCase()).getBytes(Charsets.UTF_8));
-                        }
+                    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);
             }
-            final Plot plot = new Plot(PlotArea.createGeneric(world), id, 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)");
+            PS.log("&7 - Converting from a non-uuid version of PlotMe can't identify owners if the playerdata files are deleted (these plots will "
+                    + "remain unknown until the player connects)");
         }
-        
-        for (final Entry<String, HashMap<PlotId, boolean[]>> entry : merges.entrySet()) {
-            final String world = entry.getKey();
-            for (final Entry<PlotId, boolean[]> entry2 : entry.getValue().entrySet()) {
-                final HashMap<PlotId, Plot> newplots = plots.get(world);
-                final Plot plot = newplots.get(entry2.getKey());
+
+        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());
                 }
             }
         }
-        
-        r.close();
-        stmt.close();
+
+        resultSet.close();
+        statement.close();
 
         try {
 
-            PS.log(" - " + prefix + "Denied");
-            stmt = connection.prepareStatement("SELECT * FROM `" + prefix + "Denied`");
-            r = stmt.executeQuery();
+            PS.log(" - " + this.prefix + "Denied");
+            statement = connection.prepareStatement("SELECT * FROM `" + this.prefix + "Denied`");
+            resultSet = statement.executeQuery();
 
-            while (r.next()) {
-                final PlotId id = new PlotId(r.getInt("idX"), r.getInt("idZ"));
-                final String name = r.getString("player");
-                final String world = LikePlotMeConverter.getWorld(r.getString("world"));
+            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(r, "playerid")) {
-                            try {
-                                final byte[] bytes = r.getBytes("playerid");
-                                if (bytes != null) {
-                                    try {
-                                        final ByteBuffer bb = ByteBuffer.wrap(bytes);
-                                        final long high = bb.getLong();
-                                        final long low = bb.getLong();
-                                        denied = new UUID(high, low);
-                                    } catch (final Exception e) {
-                                        e.printStackTrace();
-                                        denied = UUID.nameUUIDFromBytes(bytes);
-                                    }
-                                    UUIDHandler.add(new StringWrapper(name), denied);
-                                }
-                            } catch (SQLException e) {
-                                e.printStackTrace();
-                            }
+                    } else if (DBFunc.hasColumn(resultSet, "playerid")) {
+                        byte[] bytes = resultSet.getBytes("playerid");
+                        if (bytes != null) {
+                            ByteBuffer bb = ByteBuffer.wrap(bytes);
+                            long mostSigBits = bb.getLong();
+                            long leastSigBits = bb.getLong();
+                            denied = new UUID(mostSigBits, leastSigBits);
+                            UUIDHandler.add(new StringWrapper(name), denied);
                         }
                     }
                     if (denied == null) {
@@ -205,41 +181,34 @@ public class ClassicPlotMeConnector extends APlotMeConnector {
                         continue;
                     }
                 }
-                if (plots.get(world).containsKey(id)) {
-                    plots.get(world).get(id).getDenied().add(denied);
+                HashMap<PlotId, Plot> worldMap = plots.get(world);
+                if (worldMap != null) {
+                    Plot plot = worldMap.get(id);
+                    if (plot != null) {
+                        plot.getDenied().add(denied);
+                    }
                 }
             }
 
-            stmt = connection.prepareStatement("SELECT * FROM `" + plugin + "Allowed`");
-            r = stmt.executeQuery();
+            statement = connection.prepareStatement("SELECT * FROM `" + this.plugin + "Allowed`");
+            resultSet = statement.executeQuery();
 
-            while (r.next()) {
-                final PlotId id = new PlotId(r.getInt("idX"), r.getInt("idZ"));
-                final String name = r.getString("player");
-                final String world = LikePlotMeConverter.getWorld(r.getString("world"));
+            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(r, "playerid")) {
-                            try {
-                                final byte[] bytes = r.getBytes("playerid");
-                                if (bytes != null) {
-                                    try {
-                                        final ByteBuffer bb = ByteBuffer.wrap(bytes);
-                                        final long high = bb.getLong();
-                                        final long low = bb.getLong();
-                                        helper = new UUID(high, low);
-                                    } catch (final Exception e) {
-                                        e.printStackTrace();
-                                        helper = UUID.nameUUIDFromBytes(bytes);
-                                    }
-                                    UUIDHandler.add(new StringWrapper(name), helper);
-                                }
-                            } catch (SQLException e) {
-                                e.printStackTrace();
-                            }
+                    } else if (DBFunc.hasColumn(resultSet, "playerid")) {
+                        byte[] bytes = resultSet.getBytes("playerid");
+                        if (bytes != null) {
+                            ByteBuffer bb = ByteBuffer.wrap(bytes);
+                            long mostSigBits = bb.getLong();
+                            long leastSigBits = bb.getLong();
+                            helper = new UUID(mostSigBits, leastSigBits);
+                            UUIDHandler.add(new StringWrapper(name), helper);
                         }
                     }
                     if (helper == null) {
@@ -247,21 +216,24 @@ public class ClassicPlotMeConnector extends APlotMeConnector {
                         continue;
                     }
                 }
-                if (plots.get(world).containsKey(id)) {
-                    plots.get(world).get(id).getTrusted().add(helper);
+                HashMap<PlotId, Plot> worldMap = plots.get(world);
+                if (worldMap != null) {
+                    Plot plot = worldMap.get(id);
+                    if (plot != null) {
+                        plot.getTrusted().add(helper);
+                    }
                 }
             }
 
-            r.close();
-            stmt.close();
+            resultSet.close();
+            statement.close();
 
-        } catch (SQLException e) {
-        }
+        } catch (SQLException ignored) {}
         return plots;
     }
-    
+
     @Override
-    public boolean accepts(final String version) {
+    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

@@ -1,23 +1,3 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// PlotSquared - A plot manager and world generator for the Bukkit API                             /
-// Copyright (c) 2014 IntellectualSites/IntellectualCrafters                                       /
-//                                                                                                 /
-// This program is free software; you can redistribute it and/or modify                            /
-// it under the terms of the GNU General Public License as published by                            /
-// the Free Software Foundation; either version 3 of the License, or                               /
-// (at your option) any later version.                                                             /
-//                                                                                                 /
-// This program is distributed in the hope that it will be useful,                                 /
-// but WITHOUT ANY WARRANTY; without even the implied warranty of                                  /
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                   /
-// GNU General Public License for more details.                                                    /
-//                                                                                                 /
-// You should have received a copy of the GNU General Public License                               /
-// along with this program; if not, write to the Free Software Foundation,                         /
-// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA                               /
-//                                                                                                 /
-// You can contact us via: support@intellectualsites.com                                           /
-////////////////////////////////////////////////////////////////////////////////////////////////////
 package com.plotsquared.bukkit.database.plotme;
 
 import com.intellectualcrafters.configuration.MemorySection;
@@ -35,15 +15,16 @@ 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.Charset;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.sql.Connection;
+import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -51,60 +32,47 @@ import java.util.Map.Entry;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-/**
- * Created 2014-08-17 for PlotSquared
- *
-
-
- */
 public class LikePlotMeConverter {
+
     private final String plugin;
-    
-    /**
-     * Constructor
-     *
-     * @param plugin Plugin Used to run the converter
-     */
-    public LikePlotMeConverter(final String plugin) {
+
+    public LikePlotMeConverter(String plugin) {
         this.plugin = plugin;
     }
-    
-    public static String getWorld(final String world) {
-        for (final World newworld : Bukkit.getWorlds()) {
-            if (newworld.getName().equalsIgnoreCase(world)) {
-                return newworld.getName();
+
+    public static String getWorld(String world) {
+        for (World newWorld : Bukkit.getWorlds()) {
+            if (newWorld.getName().equalsIgnoreCase(world)) {
+                return newWorld.getName();
             }
         }
         return world;
     }
-    
-    private void sendMessage(final String message) {
+
+    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 + plugin + File.separator;
     }
-    
-    public String getAthionPlotsPath() {
-        return new File(".").getAbsolutePath() + File.separator + "plugins" + File.separator + plugin + File.separator;
-    }
-    
-    public FileConfiguration getPlotMeConfig(final String dataFolder) {
-        final File plotMeFile = new File(dataFolder + "config.yml");
+
+    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(final FileConfiguration plotConfig) {
+
+    public Set<String> getPlotMeWorlds(FileConfiguration plotConfig) {
         return plotConfig.getConfigurationSection("worlds").getKeys(false);
     }
-    
-    public void mergeWorldYml(final String plugin, FileConfiguration plotConfig) {
+
+    public void mergeWorldYml(FileConfiguration plotConfig) {
         try {
-            File genConfig = new File("plugins" + File.separator + plugin + File.separator + "PlotMe-DefaultGenerator" + File.separator + "config.yml");
+            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)) {
@@ -116,36 +84,35 @@ public class LikePlotMeConverter {
                     }
                 }
             }
-        }
-        catch (Exception e) {
+        } catch (Exception e) {
             e.printStackTrace();
         }
     }
-    
-    public void updateWorldYml(final String plugin, final String location) {
+
+    public void updateWorldYml(String location) {
         try {
-            final Path path = Paths.get(location);
-            final File file = new File(location);
+            Path path = Paths.get(location);
+            File file = new File(location);
             if (!file.exists()) {
                 return;
             }
-            final Charset charset = StandardCharsets.UTF_8;
-            String content = new String(Files.readAllBytes(path), charset);
-            content = content.replaceAll("PlotMe-DefaultGenerator", "PlotSquared");
-            content = content.replaceAll(plugin, "PlotSquared");
-            Files.write(path, content.getBytes(charset));
-        } catch (IOException e) {
-        }
+            String content = new String(Files.readAllBytes(path), StandardCharsets.UTF_8);
+            content = content.replace("PlotMe-DefaultGenerator", "PlotSquared");
+            content = content.replace("PlotMe", "PlotSquared");
+            content = content.replace("AthionPlots", "PlotSquared");
+            content = content.replace("PlotZWorld", "PlotSquared");
+            Files.write(path, content.getBytes(StandardCharsets.UTF_8));
+        } catch (IOException ignored) {}
     }
-    
-    public boolean run(final APlotMeConnector connector) {
+
+    public boolean run(APlotMeConnector connector) {
         try {
-            final String dataFolder = getPlotMePath();
-            final FileConfiguration plotConfig = getPlotMeConfig(dataFolder);
+            String dataFolder = getPlotMePath();
+            FileConfiguration plotConfig = getPlotMeConfig(dataFolder);
             if (plotConfig == null) {
                 return false;
             }
-            
+
             String version = plotConfig.getString("Version");
             if (version == null) {
                 version = plotConfig.getString("version");
@@ -153,121 +120,93 @@ public class LikePlotMeConverter {
             if (!connector.accepts(version)) {
                 return false;
             }
-            
+
             PS.debug("&3Using connector: " + connector.getClass().getCanonicalName());
-            
-            final Connection connection = connector.getPlotMeConnection(plugin, plotConfig, dataFolder);
-            
+
+            Connection connection = connector.getPlotMeConnection(plotConfig, dataFolder);
+
             if (!connector.isValidConnection(connection)) {
                 sendMessage("Cannot connect to PlotMe DB. Conversion process will not continue");
                 return false;
             }
-            
-            sendMessage(plugin + " conversion has started. To disable this, please set 'plotme-convert.enabled' to false in the 'settings.yml'");
-            
-            mergeWorldYml(plugin, plotConfig);
-            
-            sendMessage("Connecting to " + plugin + " DB");
-            
-            int plotCount = 0;
-            final ArrayList<Plot> createdPlots = new ArrayList<>();
-            
+
+            sendMessage("PlotMe conversion has started. To disable this, please set 'plotme-convert.enabled' to false in the 'settings.yml'");
+
+            mergeWorldYml(plotConfig);
+
+            sendMessage("Connecting to PlotMe DB");
+
+            ArrayList<Plot> createdPlots = new ArrayList<>();
+
             sendMessage("Collecting plot data");
-            
-            final String dbPrefix = plugin.toLowerCase();
+
+            String dbPrefix = "PlotMe".toLowerCase();
             sendMessage(" - " + dbPrefix + "Plots");
             final Set<String> worlds = getPlotMeWorlds(plotConfig);
-            
-            if (Settings.CONVERT_PLOTME) {
+
+            if (Settings.Enabled_Components.PLOTME_CONVERTER) {
                 sendMessage("Updating bukkit.yml");
-                updateWorldYml(plugin, "bukkit.yml");
-                updateWorldYml(plugin, "plugins/Multiverse-Core/worlds.yml");
-                for (final String world : plotConfig.getConfigurationSection("worlds").getKeys(false)) {
+                updateWorldYml("bukkit.yml");
+                updateWorldYml("plugins/Multiverse-Core/worlds.yml");
+                for (String world : plotConfig.getConfigurationSection("worlds").getKeys(false)) {
                     sendMessage("Copying config for: " + world);
                     try {
-                        final String actualWorldName = getWorld(world);
+                        String actualWorldName = getWorld(world);
                         connector.copyConfig(plotConfig, world, actualWorldName);
-                        PS.get().config.save(PS.get().configFile);
-                    } catch (final Exception e) {
+                        PS.get().worlds.save(PS.get().worldsFile);
+                    } 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");
+                        sendMessage("&c-- &lFailed to save configuration for world '" + world
+                                + "'\nThis will need to be done using the setup command, or manually");
                     }
                 }
             }
-            final HashMap<String, HashMap<PlotId, Plot>> plots = connector.getPlotMePlots(connection);
-            for (final Entry<String, HashMap<PlotId, Plot>> entry : plots.entrySet()) {
+            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) {
+            if (!Settings.Enabled_Components.PLOTME_CONVERTER) {
                 return false;
             }
-            
-            sendMessage(" - " + dbPrefix + "Allowed");
-            
-            sendMessage("Collected " + plotCount + " plots from PlotMe");
-            final File PLOTME_DG_FILE = new File(dataFolder + File.separator + "PlotMe-DefaultGenerator" + File.separator + "config.yml");
-            if (PLOTME_DG_FILE.exists()) {
-                final YamlConfiguration PLOTME_DG_YML = YamlConfiguration.loadConfiguration(PLOTME_DG_FILE);
-                try {
-                    for (final String world : plots.keySet()) {
-                        final String actualWorldName = getWorld(world);
-                        final String plotMeWorldName = world.toLowerCase();
-                        Integer pathwidth = PLOTME_DG_YML.getInt("worlds." + plotMeWorldName + ".PathWidth"); //
-                        /*
-                         * TODO: dead code
-                         * 
-                        if (pathwidth == null) {
-                            pathwidth = 7;
-                        }
-                        */
-                        PS.get().config.set("worlds." + world + ".road.width", pathwidth);
 
-                        Integer pathheight = PLOTME_DG_YML.getInt("worlds." + plotMeWorldName + ".RoadHeight"); //
-                        if (pathheight == 0) {
-                            pathheight = 64;
-                        }
-                        PS.get().config.set("worlds." + world + ".road.height", pathheight);
-                        PS.get().config.set("worlds." + world + ".wall.height", pathheight);
-                        PS.get().config.set("worlds." + world + ".plot.height", pathheight);
-                        Integer plotsize = PLOTME_DG_YML.getInt("worlds." + plotMeWorldName + ".PlotSize"); //
-                        if (plotsize == 0) {
-                            plotsize = 32;
-                        }
-                        PS.get().config.set("worlds." + world + ".plot.size", plotsize);
-                        String wallblock = PLOTME_DG_YML.getString("worlds." + plotMeWorldName + ".WallBlock"); //
-                        if (wallblock == null) {
-                            wallblock = "44";
-                        }
-                        PS.get().config.set("worlds." + world + ".wall.block", wallblock);
-                        String floor = PLOTME_DG_YML.getString("worlds." + plotMeWorldName + ".PlotFloorBlock"); //
-                        if (floor == null) {
-                            floor = "2";
-                        }
-                        PS.get().config.set("worlds." + world + ".plot.floor", Collections.singletonList(floor));
-                        String filling = PLOTME_DG_YML.getString("worlds." + plotMeWorldName + ".FillBlock"); //
-                        if (filling == null) {
-                            filling = "3";
-                        }
-                        PS.get().config.set("worlds." + world + ".plot.filling", Collections.singletonList(filling));
-                        String road = PLOTME_DG_YML.getString("worlds." + plotMeWorldName + ".RoadMainBlock");
-                        if (road == null) {
-                            road = "5";
-                        }
-                        PS.get().config.set("worlds." + world + ".road.block", road);
-                        Integer height = PLOTME_DG_YML.getInt("worlds." + plotMeWorldName + ".RoadHeight"); //
+            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"); //
+                        PS.get().worlds.set("worlds." + world + ".road.width", pathWidth);
+
+                        int pathHeight = plotmeDgYml.getInt("worlds." + plotMeWorldName + ".RoadHeight", 64); //
+                        PS.get().worlds.set("worlds." + world + ".road.height", pathHeight);
+                        PS.get().worlds.set("worlds." + world + ".wall.height", pathHeight);
+                        PS.get().worlds.set("worlds." + world + ".plot.height", pathHeight);
+                        int plotSize = plotmeDgYml.getInt("worlds." + plotMeWorldName + ".PlotSize", 32); //
+                        PS.get().worlds.set("worlds." + world + ".plot.size", plotSize);
+                        String wallblock = plotmeDgYml.getString("worlds." + plotMeWorldName + ".WallBlock", "44"); //
+                        PS.get().worlds.set("worlds." + world + ".wall.block", wallblock);
+                        String floor = plotmeDgYml.getString("worlds." + plotMeWorldName + ".PlotFloorBlock", "2"); //
+                        PS.get().worlds.set("worlds." + world + ".plot.floor", Collections.singletonList(floor));
+                        String filling = plotmeDgYml.getString("worlds." + plotMeWorldName + ".FillBlock", "3"); //
+                        PS.get().worlds.set("worlds." + world + ".plot.filling", Collections.singletonList(filling));
+                        String road = plotmeDgYml.getString("worlds." + plotMeWorldName + ".RoadMainBlock", "5");
+                        PS.get().worlds.set("worlds." + world + ".road.block", road);
+                        int height = plotmeDgYml.getInt("worlds." + plotMeWorldName + ".RoadHeight"); //
                         if (height == 0) {
-                            height = PLOTME_DG_YML.getInt("worlds." + plotMeWorldName + ".GroundHeight"); //
-                            if (height == 0) {
-                                height = 64;
-                            }
+                            height = plotmeDgYml.getInt("worlds." + plotMeWorldName + ".GroundHeight", 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);
+                        PS.get().worlds.set("worlds." + actualWorldName + ".road.height", height);
+                        PS.get().worlds.set("worlds." + actualWorldName + ".plot.height", height);
+                        PS.get().worlds.set("worlds." + actualWorldName + ".wall.height", height);
+                        PS.get().worlds.save(PS.get().worldsFile);
                     }
-                } catch (IOException e) {
-                }
+                } catch (IOException ignored) {}
             }
             for (Entry<String, HashMap<PlotId, Plot>> entry : plots.entrySet()) {
                 String world = entry.getKey();
@@ -282,7 +221,8 @@ public class LikePlotMeConverter {
                         }
                     }
                     if (duplicate > 0) {
-                        PS.debug("&c[WARNING] Found " + duplicate + " duplicate plots already in DB for world: '" + world + "'. Have you run the converter already?");
+                        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) {
@@ -296,7 +236,8 @@ public class LikePlotMeConverter {
                                 }
                             }
                             if (duplicate > 0) {
-                                PS.debug("&c[WARNING] Found " + duplicate + " duplicate plots already in DB for world: '" + world + "'. Have you run the converter already?");
+                                PS.debug("&c[WARNING] Found " + duplicate + " duplicate plots already in DB for world: '" + world
+                                        + "'. Have you run the converter already?");
                             }
                             continue;
                         }
@@ -326,58 +267,62 @@ public class LikePlotMeConverter {
             });
             sendMessage("Saving configuration...");
             try {
-                PS.get().config.save(PS.get().configFile);
-            } catch (final IOException e) {
+                PS.get().worlds.save(PS.get().worldsFile);
+            } catch (IOException ignored) {
                 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;
+                        boolean mv = false;
+                        boolean mw = false;
+                        if ((Bukkit.getPluginManager().getPlugin("Multiverse-Core") != null) && Bukkit.getPluginManager().getPlugin("Multiverse-Core")
+                                .isEnabled()) {
+                            mv = true;
+                        } else if ((Bukkit.getPluginManager().getPlugin("MultiWorld") != null) && Bukkit.getPluginManager().getPlugin("MultiWorld")
+                                .isEnabled()) {
+                            mw = true;
                         }
-                        for (final String worldname : worlds) {
-                            final World world = Bukkit.getWorld(getWorld(worldname));
+                        for (String worldName : worlds) {
+                            World world = Bukkit.getWorld(getWorld(worldName));
                             if (world == null) {
-                                sendMessage("&cInvalid world in PlotMe configuration: " + worldname);
+                                sendMessage("&cInvalid world in PlotMe configuration: " + worldName);
                             }
-                            final String actualWorldName = world.getName();
+                            String actualWorldName = world.getName();
                             sendMessage("Reloading generator for world: '" + actualWorldName + "'...");
                             PS.get().removePlotAreas(actualWorldName);
-                            if (MV) {
+                            if (mv) {
                                 // unload world with MV
                                 Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), "mv unload " + actualWorldName);
                                 try {
                                     Thread.sleep(1000);
-                                } catch (final InterruptedException ex) {
+                                } catch (InterruptedException ignored) {
                                     Thread.currentThread().interrupt();
                                 }
                                 // load world with MV
-                                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), "mv import " + actualWorldName + " normal -g PlotSquared");
-                            } else if (MW) {
+                                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(),
+                                        "mv import " + actualWorldName + " normal -g PlotSquared");
+                            } else if (mw) {
                                 // unload world with MW
                                 Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), "mw unload " + actualWorldName);
                                 try {
                                     Thread.sleep(1000);
-                                } catch (final InterruptedException ex) {
+                                } catch (InterruptedException ignored) {
                                     Thread.currentThread().interrupt();
                                 }
                                 // load world with MW
-                                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), "mw create " + actualWorldName + " plugin:PlotSquared");
+                                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(),
+                                        "mw create " + actualWorldName + " plugin:PlotSquared");
                             } else {
                                 // Load using Bukkit API
                                 // - User must set generator manually
                                 Bukkit.getServer().unloadWorld(world, true);
-                                final World myworld = WorldCreator.name(actualWorldName).generator(new BukkitPlotGenerator(new HybridGen())).createWorld();
-                                myworld.save();
+                                World myWorld = WorldCreator.name(actualWorldName).generator(new BukkitPlotGenerator(new HybridGen())).createWorld();
+                                myWorld.save();
                             }
                         }
-                    } catch (final Exception e) {
+                    } catch (CommandException e) {
                         e.printStackTrace();
                     }
                     if (done.get()) {
@@ -393,13 +338,13 @@ public class LikePlotMeConverter {
                     }
                 }
             });
-        } catch (final Exception e) {
+        } catch (InterruptedException | SQLException 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Bukkit/src/main/java/com/plotsquared/bukkit/events/PlotComponentSetEvent.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.HandlerList;
+
+/**
+ * Called when a plot component is set
+ *
+ */
+public class PlotComponentSetEvent extends PlotEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final String component;
+
+    public PlotComponentSetEvent(Plot plot, String component) {
+        super(plot);
+        this.component = component;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Get the PlotId
+     *
+     * @return PlotId
+     */
+    public PlotId getPlotId() {
+        return getPlot().getId();
+    }
+
+    /**
+     * Get the world name
+     *
+     * @return String
+     */
+    public String getWorld() {
+        return getPlot().getArea().worldname;
+    }
+
+    /**
+     * Get the component which was set
+     *
+     * @return Component name
+     */
+    public String getComponent() {
+        return this.component;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+}

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

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

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

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

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

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

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

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

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

@@ -1,44 +1,20 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// PlotSquared - A plot manager and world generator for the Bukkit API                             /
-// Copyright (c) 2014 IntellectualSites/IntellectualCrafters                                       /
-//                                                                                                 /
-// This program is free software; you can redistribute it and/or modify                            /
-// it under the terms of the GNU General Public License as published by                            /
-// the Free Software Foundation; either version 3 of the License, or                               /
-// (at your option) any later version.                                                             /
-//                                                                                                 /
-// This program is distributed in the hope that it will be useful,                                 /
-// but WITHOUT ANY WARRANTY; without even the implied warranty of                                  /
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                   /
-// GNU General Public License for more details.                                                    /
-//                                                                                                 /
-// You should have received a copy of the GNU General Public License                               /
-// along with this program; if not, write to the Free Software Foundation,                         /
-// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA                               /
-//                                                                                                 /
-// You can contact us via: support@intellectualsites.com                                           /
-////////////////////////////////////////////////////////////////////////////////////////////////////
 package com.plotsquared.bukkit.events;
 
-import java.util.ArrayList;
-
-import org.bukkit.World;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-
 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;
 
-/**
-
- */
-public class PlotMergeEvent extends Event implements Cancellable {
+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;
-    private boolean cancelled;
-    private Plot plot;
-    private World world;
+
     /**
      * PlotMergeEvent: Called when plots are merged
      *
@@ -46,48 +22,41 @@ public class PlotMergeEvent extends Event implements Cancellable {
      * @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() {
-    public ArrayList<PlotId> getPlots() {
+        return this.plots;
     }
-    }
-    
-    /**
-     * Get the main plot
-     *
-     * @return Plot
-     */
-    public Plot getPlot() {
-        return plot;
-    }
+
     public World getWorld() {
-    public World getWorld() {
+        return this.world;
     }
-    }
+
     @Override
     public HandlerList getHandlers() {
         return handlers;
     }
-    }
+
     @Override
     public boolean isCancelled() {
-    public boolean isCancelled() {
+        return this.cancelled;
     }
-    }
+
     @Override
-    @Override
-    public void setCancelled(final boolean b) {
+    public void setCancelled(boolean b) {
+        this.cancelled = b;
     }
 }

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

@@ -1,46 +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;
+import org.bukkit.event.HandlerList;
 
-/**
- * Created 2015-07-13 for PlotSquaredGit
- *
-
 public class PlotRateEvent extends PlotEvent {
-public class PlotRateEvent extends PlotEvent {
-    
+
+    private static final HandlerList handlers = new HandlerList();
     private final PlotPlayer rater;
     private Rating rating;
-    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() {
-    public PlotPlayer getRater() {
+        return this.rater;
     }
-    }
-    
+
+    public Rating getRating() {
+        return this.rating;
+    }
+
+    public void setRating(Rating rating) {
         this.rating = rating;
     }
-    }
-    
-    public Rating getRating() {
-        return rating;
-    }
+
     @Override
     public HandlerList getHandlers() {
         return handlers;
     }
-    }
+
 }

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

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

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

@@ -10,8 +10,6 @@ import java.util.Random;
 public class BukkitAugmentedGenerator extends BlockPopulator {
     
     private static BukkitAugmentedGenerator generator;
-    
-    private BukkitAugmentedGenerator() {}
 
     public static BukkitAugmentedGenerator get(World world) {
         for (BlockPopulator populator : world.getPopulators()) {
@@ -27,7 +25,7 @@ public class BukkitAugmentedGenerator extends BlockPopulator {
     }
 
     @Override
-    public void populate(final World world, Random r, final Chunk chunk) {
+    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

@@ -1,72 +1,82 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// 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.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.*;
+import com.intellectualcrafters.plot.object.ChunkLoc;
+import com.intellectualcrafters.plot.object.ChunkWrapper;
+import com.intellectualcrafters.plot.object.Location;
+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.intellectualcrafters.plot.util.MathMan;
+import com.intellectualcrafters.plot.util.block.GlobalBlockQueue;
+import com.intellectualcrafters.plot.util.block.LocalBlockQueue;
+import com.intellectualcrafters.plot.util.block.ScopedLocalBlockQueue;
 import com.plotsquared.bukkit.util.BukkitUtil;
 import com.plotsquared.bukkit.util.block.GenChunk;
+import java.util.ArrayList;
+import java.util.HashMap;
+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;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-import java.util.Set;
-
 public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrapper<ChunkGenerator> {
     
-    private final PlotChunk<Chunk> chunkSetter;
+    private final GenChunk 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 final HashMap<ChunkLoc, byte[][]> dataMap = new HashMap<>();
     private boolean loaded = false;
-    private ChunkGenerator platformGenerator;
-    private boolean full;
 
     public BukkitPlotGenerator(IndependentPlotGenerator generator) {
+        if (generator == null) {
+            throw new IllegalArgumentException("Generator may not be null!");
+        }
         this.plotGenerator = generator;
         this.platformGenerator = this;
-        populators.add(new BlockPopulator() {
+        this.populators.add(new BlockPopulator() {
+
+            private LocalBlockQueue queue;
+
             @Override
             public void populate(World world, Random r, Chunk c) {
-                if (!(chunkSetter instanceof GenChunk)) {
-                    PS.debug("Current PlotChunk is not relevant to population?");
-                    PS.stacktrace();
-                    return;
+                if (queue == null) {
+                    queue = GlobalBlockQueue.IMP.getNewQueue(world.getName(), false);
                 }
-                GenChunk result = (GenChunk) chunkSetter;
-                if (result.result_data != null) {
-                    for (int i = 0; i < result.result_data.length; i++) {
-                        byte[] section = result.result_data[i];
+                ChunkLoc loc = new ChunkLoc(c.getX(), c.getZ());
+                byte[][] resultData;
+                if (!BukkitPlotGenerator.this.dataMap.containsKey(loc)) {
+                    GenChunk result = BukkitPlotGenerator.this.chunkSetter;
+                    // Set the chunk location
+                    result.setChunk(c);
+                    // Set the result data
+                    result.result = new short[16][];
+                    result.result_data = new byte[16][];
+                    result.grid = null;
+                    result.cd = null;
+                    // Catch any exceptions (as exceptions usually thrown)
+                    generate(world, loc.x, loc.z, result);
+                    resultData = result.result_data;
+                } else {
+                    resultData = BukkitPlotGenerator.this.dataMap.remove(loc);
+                }
+                if (resultData != null) {
+                    for (int i = 0; i < resultData.length; i++) {
+                        byte[] section = resultData[i];
                         if (section == null) {
                             continue;
                         }
@@ -78,9 +88,16 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
                         }
                     }
                 }
+                BukkitPlotGenerator.this.random.state = c.getX() << 16 | c.getZ() & 0xFFFF;
+                PlotArea area = PS.get().getPlotArea(world.getName(), null);
+                ChunkWrapper wrap = new ChunkWrapper(area.worldname, c.getX(), c.getZ());
+                ScopedLocalBlockQueue chunk = queue.getForChunk(wrap.x, wrap.z);
+                if (BukkitPlotGenerator.this.plotGenerator.populateChunk(chunk, area, BukkitPlotGenerator.this.random)) {
+                    queue.flush();
+                }
             }
         });
-        chunkSetter = new GenChunk(null, null);
+        this.chunkSetter = new GenChunk(null, null);
         this.full = true;
         MainUtil.initCache();
     }
@@ -90,9 +107,9 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
             throw new IllegalArgumentException("ChunkGenerator: " + cg.getClass().getName() + " is already a BukkitPlotGenerator!");
         }
         this.full = false;
-        PS.get().debug("BukkitPlotGenerator does not fully support: " + cg);
-        platformGenerator = cg;
-        plotGenerator = new IndependentPlotGenerator() {
+        PS.debug("BukkitPlotGenerator does not fully support: " + cg);
+        this.platformGenerator = cg;
+        this.plotGenerator = new IndependentPlotGenerator() {
             @Override
             public void processSetup(SetupObject setup) {}
             
@@ -115,13 +132,16 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
             }
             
             @Override
-            public void generateChunk(final PlotChunk<?> result, final PlotArea settings, final PseudoRandom random) {
+            public void generateChunk(final ScopedLocalBlockQueue result, PlotArea settings, PseudoRandom random) {
                 World w = BukkitUtil.getWorld(world);
-                Random r = new Random(result.getChunkWrapper().hashCode());
+                Location min = result.getMin();
+                int cx = min.getX() >> 4;
+                int cz = min.getZ() >> 4;
+                Random r = new Random(MathMan.pair((short) cx, (short) cz));
                 BiomeGrid grid = new BiomeGrid() {
                     @Override
                     public void setBiome(int x, int z, Biome biome) {
-                        result.setBiome(x, z, biome.ordinal());
+                        result.setBiome(x, z, biome.name());
                     }
                     
                     @Override
@@ -131,14 +151,13 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
                 };
                 try {
                     // ChunkData will spill a bit
-                    ChunkData data = cg.generateChunkData(w, r, result.getX(), result.getZ(), grid);
+                    ChunkData data = cg.generateChunkData(w, r, cx, cz, grid);
                     if (data != null) {
                         return;
                     }
-                }
-                catch (Throwable e) {}
+                } catch (Throwable ignored) {}
                 // Populator spillage
-                short[][] tmp = cg.generateExtBlockSections(w, r, result.getX(), result.getZ(), grid);
+                short[][] tmp = cg.generateExtBlockSections(w, r, cx, cz, grid);
                 if (tmp != null) {
                     for (int i = 0; i < tmp.length; i++) {
                         short[] section = tmp[i];
@@ -163,13 +182,13 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
                     }
                 }
                 for (BlockPopulator populator : cg.getDefaultPopulators(w)) {
-                    populator.populate(w, r, (Chunk) result.getChunk());
+                    populator.populate(w, r, w.getChunkAt(cx, cz));
                 }
             }
         };
-        chunkSetter = new GenChunk(null, SetQueue.IMP.new ChunkWrapper(world, 0, 0));
+        this.chunkSetter = new GenChunk(null, new ChunkWrapper(world, 0, 0));
         if (cg != null) {
-            populators.addAll(cg.getDefaultPopulators(BukkitUtil.getWorld(world)));
+            this.populators.addAll(cg.getDefaultPopulators(BukkitUtil.getWorld(world)));
         }
         MainUtil.initCache();
     }
@@ -181,24 +200,24 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
     
     @Override
     public boolean isFull() {
-        return full;
+        return this.full;
     }
     
     @Override
     public IndependentPlotGenerator getPlotGenerator() {
-        return plotGenerator;
+        return this.plotGenerator;
     }
     
     @Override
     public ChunkGenerator getPlatformGenerator() {
-        return platformGenerator;
+        return this.platformGenerator;
     }
 
     @Override
-    public List<BlockPopulator> getDefaultPopulators(final World world) {
+    public List<BlockPopulator> getDefaultPopulators(World world) {
         try {
-            if (!loaded) {
-                final String name = world.getName();
+            if (!this.loaded) {
+                String name = world.getName();
                 PS.get().loadWorld(name, this);
                 Set<PlotArea> areas = PS.get().getPlotAreas(name);
                 if (!areas.isEmpty()) {
@@ -219,32 +238,36 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
                         world.setWaterAnimalSpawnLimit(-1);
                     }
                 }
-                loaded = true;
+                this.loaded = true;
             }
-        } catch (final Exception e) {
+        } catch (Exception e) {
             e.printStackTrace();
         }
-        return populators;
+        ArrayList<BlockPopulator> toAdd = new ArrayList<>();
+        List<BlockPopulator> existing = world.getPopulators();
+        for (BlockPopulator populator : this.populators) {
+            if (!existing.contains(populator)) {
+                toAdd.add(populator);
+            }
+        }
+        return toAdd;
     }
-    
+
     @Override
     public ChunkData generateChunkData(World world, Random random, int cx, int cz, BiomeGrid grid) {
-        if (!(chunkSetter instanceof GenChunk)) {
-            PS.debug("Current PlotChunk is not relevant to generation?");
-            PS.stacktrace();
-            return null;
-        }
-        GenChunk result = (GenChunk) chunkSetter;
+        GenChunk result = (GenChunk) this.chunkSetter;
         // Set the chunk location
-        result.setChunkWrapper(SetQueue.IMP.new ChunkWrapper(world.getName(), cx, cz));
+        result.setChunk(new ChunkWrapper(world.getName(), cx, cz));
         // Set the result data
         result.cd = createChunkData(world);
         result.grid = grid;
-        // Catch any exceptions (as exceptions usually thrown 
+        result.result = null;
+        result.result_data = null;
+        // Catch any exceptions (as exceptions usually thrown)
         try {
             // Fill the result data if necessary
-            if (platformGenerator != this) {
-                return platformGenerator.generateChunkData(world, random, cx, cz, grid);
+            if (this.platformGenerator != this) {
+                return this.platformGenerator.generateChunkData(world, random, cx, cz, grid);
             } else {
                 generate(world, cx, cz, result);
             }
@@ -254,48 +277,49 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
         // Return the result data
         return result.cd;
     }
-    
-    public void generate(World world, int cx, int cz, GenChunk result) {
+
+    public void generate(World world, int cx, int cz, ScopedLocalBlockQueue result) {
         // Load if improperly loaded
-        if (!loaded) {
-            final String name = world.getName();
+        if (!this.loaded) {
+            String name = world.getName();
             PS.get().loadWorld(name, this);
-            loaded = true;
+            this.loaded = true;
         }
         // Set random seed
-        this.random.state = (cx << 16) | (cz & 0xFFFF);
+        this.random.state = cx << 16 | cz & 0xFFFF;
         // Process the chunk
-        result.modified = false;
-        ChunkManager.preProcessChunk(result);
-        if (result.modified) {
+        if (ChunkManager.preProcessChunk(result)) {
             return;
         }
         PlotArea area = PS.get().getPlotArea(world.getName(), null);
-        plotGenerator.generateChunk(chunkSetter, area, this.random);
+        try {
+            this.plotGenerator.generateChunk(this.chunkSetter, area, this.random);
+        } catch (Throwable e) {
+            // Recover from generator error
+            e.printStackTrace();
+        }
         ChunkManager.postProcessChunk(result);
-        return;
     }
     
     @Override
-    public short[][] generateExtBlockSections(final World world, final Random r, final int cx, final int cz, final BiomeGrid grid) {
-        if (!(chunkSetter instanceof GenChunk)) {
-            PS.stacktrace();
-            return new short[16][];
-        }
-        GenChunk result = (GenChunk) chunkSetter;
+    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));
+        result.setChunk(new ChunkWrapper(world.getName(), cx, cz));
         // Set the result data
         result.result = new short[16][];
         result.result_data = new byte[16][];
         result.grid = grid;
-        // Catch any exceptions (as exceptions usually thrown 
+        result.cd = null;
+        // Catch any exceptions (as exceptions usually thrown)
         try {
             // Fill the result data
-            if (platformGenerator != this) {
-                return platformGenerator.generateExtBlockSections(world, r, cx, cz, grid);
+            if (this.platformGenerator != this) {
+                return this.platformGenerator.generateExtBlockSections(world, r, cx, cz, grid);
             } else {
                 generate(world, cx, cz, result);
+                this.dataMap.put(new ChunkLoc(cx, cz), result.result_data);
+
             }
         } catch (Throwable e) {
             e.printStackTrace();
@@ -305,19 +329,27 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
     }
     
     /**
-     * Allow spawning everywhere
+     * Allow spawning everywhere.
+     * @param world Ignored
+     * @param x Ignored
+     * @param z Ignored
+     * @return always true
      */
     @Override
-    public boolean canSpawn(final World world, final int x, final int z) {
+    public boolean canSpawn(World world, int x, int z) {
         return true;
     }
     
     @Override
     public String toString() {
-        if (platformGenerator == this) {
-            return "" + plotGenerator;
+        if (this.platformGenerator == this) {
+            return this.plotGenerator.getName();
+        }
+        if (this.platformGenerator == null) {
+            return "null";
+        } else {
+            return this.platformGenerator.getClass().getName();
         }
-        return platformGenerator == null ? "null" : platformGenerator.getClass().getName();
     }
     
     @Override
@@ -325,6 +357,6 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
         if (obj == null) {
             return false;
         }
-        return (toString().equals(obj.toString()) || toString().equals(obj.getClass().getName()));
+        return toString().equals(obj.toString()) || toString().equals(obj.getClass().getName());
     }
 }

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

@@ -4,15 +4,12 @@ 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;
@@ -31,167 +28,122 @@ 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;
+import java.lang.reflect.Method;
+import java.util.HashSet;
 
 public class ChunkListener implements Listener {
-    
-    private final RefClass classChunk = getRefClass("{nms}.Chunk");
-    private final RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
-    private final RefField mustSave = classChunk.getField("mustSave");
-    private Chunk lastChunk = null;
+
     private RefMethod methodGetHandleChunk;
-    
+    private RefField mustSave;
+    private Chunk lastChunk;
+
     
     public ChunkListener() {
-        RefMethod method;
-        try {
-            method = classCraftChunk.getMethod("getHandle");
-        } catch (final Exception e) {
-            method = null;
-            e.printStackTrace();
+        if (Settings.Chunk_Processor.AUTO_TRIM) {
+            try {
+                RefClass classChunk = getRefClass("{nms}.Chunk");
+                RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
+                this.mustSave = classChunk.getField("mustSave");
+                this.methodGetHandleChunk = classCraftChunk.getMethod("getHandle");
+            } catch (Throwable ignored) {
+                PS.debug("PlotSquared/Server not compatible for chunk processor trim/gc");
+                Settings.Chunk_Processor.AUTO_TRIM = false;
+            }
         }
-        methodGetHandleChunk = method;
-        
-        if (!Settings.CHUNK_PROCESSOR_GC) {
+        if (!Settings.Chunk_Processor.AUTO_TRIM) {
             return;
         }
-        TaskManager.runTask(new Runnable() {
+        for (World world : Bukkit.getWorlds()) {
+            world.setAutoSave(false);
+        }
+        TaskManager.runTaskRepeat(new Runnable() {
             @Override
             public void run() {
-                final int distance = Bukkit.getViewDistance() + 2;
-                final HashMap<String, HashMap<ChunkLoc, Integer>> players = new HashMap<>();
-                for (final Entry<String, PlotPlayer> entry : UUIDHandler.getPlayers().entrySet()) {
-                    final PlotPlayer pp = entry.getValue();
-                    final Location loc = pp.getLocation();
-                    final String world = loc.getWorld();
-                    if (!PS.get().hasPlotArea(world)) {
-                        continue;
-                    }
-                    HashMap<ChunkLoc, Integer> map = players.get(world);
-                    if (map == null) {
-                        map = new HashMap<>();
-                        players.put(world, map);
-                    }
-                    final ChunkLoc origin = new ChunkLoc(loc.getX() >> 4, loc.getZ() >> 4);
-                    Integer val = map.get(origin);
-                    int check;
-                    if (val != null) {
-                        if (val == distance) {
+                try {
+                    HashSet<Chunk> toUnload = new HashSet<>();
+                    for (World world : Bukkit.getWorlds()) {
+                        String worldName = world.getName();
+                        if (!PS.get().hasPlotArea(worldName)) {
                             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) {
+                        Object w = world.getClass().getDeclaredMethod("getHandle").invoke(world);
+                        Object chunkMap = w.getClass().getDeclaredMethod("getPlayerChunkMap").invoke(w);
+                        Method methodIsChunkInUse = chunkMap.getClass().getDeclaredMethod("isChunkInUse", int.class, int.class);
+                        Chunk[] chunks = world.getLoadedChunks();
+                        for (Chunk chunk : chunks) {
+                            if ((boolean) methodIsChunkInUse.invoke(chunkMap, chunk.getX(), chunk.getZ())) {
                                 continue;
                             }
-                            final int weight = distance - Math.max(Math.abs(x), Math.abs(z));
-                            final ChunkLoc chunk = new ChunkLoc(x + origin.x, z + origin.z);
-                            val = map.get(chunk);
-                            if (val == null || val < weight) {
-                                map.put(chunk, weight);
+                            int x = chunk.getX();
+                            int z = chunk.getZ();
+                            if (!shouldSave(worldName, x, z)) {
+                                unloadChunk(worldName, chunk, false);
+                                continue;
                             }
-
-                        }
-                    }
-                }
-                int time = 300;
-                for (final World world : Bukkit.getWorlds()) {
-                    final String name = world.getName();
-                    if (!PS.get().hasPlotArea(name)) {
-                        continue;
-                    }
-                    final boolean autosave = world.isAutoSave();
-                    if (autosave) {
-                        world.setAutoSave(false);
-                    }
-                    final HashMap<ChunkLoc, Integer> map = players.get(name);
-                    if (map == null || map.isEmpty()) {
-                        continue;
-                    }
-                    Chunk[] chunks = world.getLoadedChunks();
-                    ArrayDeque<Chunk> toUnload = new ArrayDeque<>();
-                    for (final Chunk chunk : chunks) {
-                        final int x = chunk.getX();
-                        final 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 (toUnload.isEmpty()) {
+                        return;
                     }
-                    if (!Settings.CHUNK_PROCESSOR_TRIM_ON_SAVE && autosave) {
-                        world.setAutoSave(true);
+                    long start = System.currentTimeMillis();
+                    for (Chunk chunk : toUnload) {
+                        if (System.currentTimeMillis() - start > 5) {
+                            return;
+                        }
+                        chunk.unload(true, false);
                     }
+                } catch (Throwable e) {
+                    e.printStackTrace();
                 }
-                TaskManager.runTaskLater(this, time);
             }
-        });
+        }, 1);
     }
-    
-    public boolean unloadChunk(final String world, final Chunk chunk) {
-        final int X = chunk.getX();
-        final int Z = chunk.getZ();
-        final int x = X << 4;
-        final int z = Z << 4;
-        final int x2 = x + 15;
-        final int z2 = z + 15;
-        Plot plot = new Location(world, x, 1, z).getOwnedPlotAbs();
-        if (plot != null && plot.hasOwner()) {
+
+    public boolean unloadChunk(String world, Chunk chunk, boolean safe) {
+        if (safe && shouldSave(world, chunk.getX(), chunk.getZ())) {
             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;
-        }
-        final Object c = methodGetHandleChunk.of(chunk).call();
-        mustSave.of(c).set(false);
+        Object c = this.methodGetHandleChunk.of(chunk).call();
+        this.mustSave.of(c).set(false);
         if (chunk.isLoaded()) {
             chunk.unload(false, false);
         }
         return true;
     }
-    
+
+    public boolean shouldSave(String world, int X, int Z) {
+        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 true;
+        }
+        plot = new Location(world, x2, 1, z2).getOwnedPlotAbs();
+        if (plot != null && plot.hasOwner()) {
+            return true;
+        }
+        plot = new Location(world, x2, 1, z).getOwnedPlotAbs();
+        if (plot != null && plot.hasOwner()) {
+            return true;
+        }
+        plot = new Location(world, x, 1, z2).getOwnedPlotAbs();
+        if (plot != null && plot.hasOwner()) {
+            return true;
+        }
+        plot = new Location(world, x + 7, 1, z + 7).getOwnedPlotAbs();
+        return plot != null && plot.hasOwner();
+    }
+
     @EventHandler
-    public void onChunkUnload(final ChunkUnloadEvent event) {
-        if (Settings.CHUNK_PROCESSOR_TRIM_ON_SAVE) {
-            final Chunk chunk = event.getChunk();
-            final String world = chunk.getWorld().getName();
+    public void onChunkUnload(ChunkUnloadEvent event) {
+        if (Settings.Chunk_Processor.AUTO_TRIM) {
+            Chunk chunk = event.getChunk();
+            String world = chunk.getWorld().getName();
             if (PS.get().hasPlotArea(world)) {
-                if (unloadChunk(world, chunk)) {
+                if (unloadChunk(world, chunk, true)) {
                     return;
                 }
             }
@@ -202,15 +154,15 @@ public class ChunkListener implements Listener {
     }
     
     @EventHandler
-    public void onChunkLoad(final ChunkLoadEvent event) {
+    public void onChunkLoad(ChunkLoadEvent event) {
         processChunk(event.getChunk(), false);
     }
     
     @EventHandler(priority = EventPriority.LOWEST)
-    public void onItemSpawn(final ItemSpawnEvent event) {
-        final Item entity = event.getEntity();
-        final Chunk chunk = entity.getLocation().getChunk();
-        if (chunk == lastChunk) {
+    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;
@@ -218,28 +170,28 @@ public class ChunkListener implements Listener {
         if (!PS.get().hasPlotArea(chunk.getWorld().getName())) {
             return;
         }
-        final Entity[] entities = chunk.getEntities();
-        if (entities.length > Settings.CHUNK_PROCESSOR_MAX_ENTITIES) {
+        Entity[] entities = chunk.getEntities();
+        if (entities.length > Settings.Chunk_Processor.MAX_ENTITIES) {
             event.getEntity().remove();
             event.setCancelled(true);
-            lastChunk = chunk;
+            this.lastChunk = chunk;
         } else {
-            lastChunk = null;
+            this.lastChunk = null;
         }
     }
     
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onBlockPhysics(final BlockPhysicsEvent event) {
-        if (Settings.CHUNK_PROCESSOR_DISABLE_PHYSICS) {
+    public void onBlockPhysics(BlockPhysicsEvent event) {
+        if (Settings.Chunk_Processor.DISABLE_PHYSICS) {
             event.setCancelled(true);
         }
     }
     
     @EventHandler(priority = EventPriority.LOWEST)
-    public void onEntitySpawn(final CreatureSpawnEvent event) {
-        final LivingEntity entity = event.getEntity();
-        final Chunk chunk = entity.getLocation().getChunk();
-        if (chunk == lastChunk) {
+    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;
@@ -247,20 +199,20 @@ public class ChunkListener implements Listener {
         if (!PS.get().hasPlotArea(chunk.getWorld().getName())) {
             return;
         }
-        final Entity[] entities = chunk.getEntities();
-        if (entities.length > Settings.CHUNK_PROCESSOR_MAX_ENTITIES) {
+        Entity[] entities = chunk.getEntities();
+        if (entities.length > Settings.Chunk_Processor.MAX_ENTITIES) {
             event.getEntity().remove();
             event.setCancelled(true);
-            lastChunk = chunk;
+            this.lastChunk = chunk;
         } else {
-            lastChunk = null;
+            this.lastChunk = null;
         }
     }
-    
-    public void cleanChunk(final Chunk chunk) {
+
+    private void cleanChunk(final Chunk chunk) {
         TaskManager.index.incrementAndGet();
         final Integer currentIndex = TaskManager.index.get();
-        final Integer task = TaskManager.runTaskRepeat(new Runnable() {
+        Integer task = TaskManager.runTaskRepeat(new Runnable() {
             @Override
             public void run() {
                 if (!chunk.isLoaded()) {
@@ -270,7 +222,7 @@ public class ChunkListener implements Listener {
                     chunk.unload(true, true);
                     return;
                 }
-                final BlockState[] tiles = chunk.getTileEntities();
+                BlockState[] tiles = chunk.getTileEntities();
                 if (tiles.length == 0) {
                     Bukkit.getScheduler().cancelTask(TaskManager.tasks.get(currentIndex));
                     TaskManager.tasks.remove(currentIndex);
@@ -278,7 +230,7 @@ public class ChunkListener implements Listener {
                     chunk.unload(true, true);
                     return;
                 }
-                final long start = System.currentTimeMillis();
+                long start = System.currentTimeMillis();
                 int i = 0;
                 while (System.currentTimeMillis() - start < 250) {
                     if (i >= tiles.length) {
@@ -295,28 +247,28 @@ public class ChunkListener implements Listener {
         }, 5);
         TaskManager.tasks.put(currentIndex, task);
     }
-    
-    public boolean processChunk(final Chunk chunk, final boolean unload) {
+
+    public boolean processChunk(Chunk chunk, boolean unload) {
         if (!PS.get().hasPlotArea(chunk.getWorld().getName())) {
             return false;
         }
-        final Entity[] entities = chunk.getEntities();
-        final BlockState[] tiles = chunk.getTileEntities();
-        if (entities.length > Settings.CHUNK_PROCESSOR_MAX_ENTITIES) {
-            for (final Entity ent : entities) {
+        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 (tiles.length > Settings.Chunk_Processor.MAX_TILES) {
             if (unload) {
                 PS.debug("[PlotSquared] &c detected unsafe chunk: " + (chunk.getX() << 4) + "," + (chunk.getX() << 4));
                 cleanChunk(chunk);
                 return true;
             }
-            for (final BlockState tile : tiles) {
+            for (BlockState tile : tiles) {
                 tile.getBlock().setType(Material.AIR, false);
             }
         }

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

@@ -1,89 +1,77 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// 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.listeners;
 
+import com.intellectualcrafters.plot.flag.Flags;
+import com.intellectualcrafters.plot.object.Location;
+import com.intellectualcrafters.plot.object.Plot;
+import com.intellectualcrafters.plot.object.PlotPlayer;
+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.Listener;
+import org.bukkit.util.Vector;
+
 import java.util.HashSet;
 import java.util.Set;
 import java.util.UUID;
 
-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 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;
-
-/**
-
 public class ForceFieldListener implements Listener {
-public class ForceFieldListener implements Listener {
-    private Set<PlotPlayer> getNearbyPlayers(final Player player, final Plot plot) {
-        final Set<PlotPlayer> players = new HashSet<>();
-        PlotPlayer pp;
-        for (final Entity entity : player.getNearbyEntities(5d, 5d, 5d)) {
+
+    private static Set<PlotPlayer> getNearbyPlayers(Player player, Plot plot) {
+        Set<PlotPlayer> players = new HashSet<>();
+        for (Entity entity : player.getNearbyEntities(5d, 5d, 5d)) {
+            PlotPlayer plotPlayer;
+            if (!(entity instanceof Player) || ((plotPlayer = BukkitUtil.getPlayer((Player) entity)) == null) || !plot.equals(plotPlayer.getCurrentPlot())) {
                 continue;
             }
-            }
-            if (!plot.isAdded(pp.getUUID())) {
+            if (!plot.isAdded(plotPlayer.getUUID())) {
+                players.add(plotPlayer);
             }
         }
         return players;
     }
-    }
-    
-    private PlotPlayer hasNearbyPermitted(final Player player, final Plot plot) {
-        PlotPlayer pp;
-        for (final Entity entity : player.getNearbyEntities(5d, 5d, 5d)) {
+
+    private static PlotPlayer hasNearbyPermitted(Player player, Plot plot) {
+        for (Entity entity : player.getNearbyEntities(5d, 5d, 5d)) {
+            if (!(entity instanceof Player)) {
                 continue;
             }
-            }
-            if (plot.isAdded(pp.getUUID())) {
+            PlotPlayer plotPlayer;
+            if ((plotPlayer = BukkitUtil.getPlayer((Player) entity)) == null) {
+                continue;
+            }
+            if (!plot.equals(plotPlayer.getCurrentPlot())) {
+                continue;
+            }
+            if (plot.isAdded(plotPlayer.getUUID())) {
+                return plotPlayer;
             }
         }
         return null;
     }
-    }
-    
-    public Vector calculateVelocity(final PlotPlayer pp, final PlotPlayer e) {
+
+    private static Vector calculateVelocity(PlotPlayer player, PlotPlayer e) {
+        Location playerLocation = player.getLocationFull();
         Location oPlayerLocation = e.getLocation();
-        Location oPlayerLocation = e.getLocation();
-        final double playerX = playerLocation.getX(), playerY = playerLocation.getY(), playerZ = playerLocation.getZ(), oPlayerX = oPlayerLocation.getX(), oPlayerY = oPlayerLocation.getY(), oPlayerZ = oPlayerLocation
-        .getZ();
+        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) {
@@ -91,30 +79,21 @@ public class ForceFieldListener implements Listener {
         }
         return new Vector(x, y, z);
     }
-    }
-    
-    @EventHandler
-    public void onPlotEntry(final PlayerEnterPlotEvent event) {
-        final Player player = event.getPlayer();
-        final PlotPlayer pp = BukkitUtil.getPlayer(player);
-        final 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)) {
-                final UUID uuid = pp.getUUID();
-                if (plot.isAdded(uuid)) {
-                    final Set<PlotPlayer> players = getNearbyPlayers(player, plot);
-                    for (final PlotPlayer oPlayer : players) {
-                        ((BukkitPlayer) oPlayer).player.setVelocity(calculateVelocity(pp, oPlayer));
-                    }
-                } else {
-                    final PlotPlayer oPlayer = hasNearbyPermitted(player, plot);
-                    if (oPlayer == null) {
-                        return;
-                    }
+
+    public static void handleForcefield(Player player, PlotPlayer plotPlayer, Plot plot) {
+        if (Flags.FORCEFIELD.isTrue(plot)) {
+            UUID uuid = plotPlayer.getUUID();
+            if (plot.isAdded(uuid)) {
+                Set<PlotPlayer> players = getNearbyPlayers(player, plot);
+                for (PlotPlayer oPlayer : players) {
+                    ((BukkitPlayer) oPlayer).player.setVelocity(calculateVelocity(plotPlayer, oPlayer));
                 }
+            } else {
+                PlotPlayer oPlayer = hasNearbyPermitted(player, plot);
+                if (oPlayer == null) {
+                    return;
+                }
+                player.setVelocity(calculateVelocity(oPlayer, plotPlayer));
             }
         }
     }

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.Flags;
+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 location = BukkitUtil.getLocation(block.getLocation());
+        String world = location.getWorld();
+        if (!PS.get().hasPlotArea(world)) {
+            return;
+        }
+        PlotArea area = location.getPlotArea();
+        if (area == null) {
+            Iterator<Block> iterator = event.blockList().iterator();
+            while (iterator.hasNext()) {
+                location = BukkitUtil.getLocation(iterator.next().getLocation());
+                if (location.getPlotArea() != null) {
+                    iterator.remove();
+                }
+            }
+            return;
+        }
+        Plot plot = area.getOwnedPlot(location);
+        if (plot == null || !plot.getFlag(Flags.EXPLOSION).or(false)) {
+            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,48 +26,42 @@ 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.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 java.util.HashSet;
+import java.util.List;
+import java.util.UUID;
 
 public class PlayerEvents_1_8 extends PlotListener implements Listener {
     
+    @SuppressWarnings("deprecation")
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onInventoryClick(final InventoryClickEvent event) {
+    public void onInventoryClick(InventoryClickEvent event) {
         if (!event.isLeftClick() || (event.getAction() != InventoryAction.PLACE_ALL) || event.isShiftClick()) {
             return;
         }
-        final HumanEntity entity = event.getWhoClicked();
+        HumanEntity entity = event.getWhoClicked();
         if (!(entity instanceof Player) || !PS.get().hasPlotArea(entity.getWorld().getName())) {
             return;
         }
-        final Player player = (Player) entity;
-        final PlayerInventory inv = player.getInventory();
-        final int slot = inv.getHeldItemSlot();
+        Player player = (Player) entity;
+        PlayerInventory inv = player.getInventory();
+        int slot = inv.getHeldItemSlot();
         if ((slot != event.getSlot()) || (slot > 8) || !event.getEventName().equals("InventoryCreativeEvent")) {
             return;
         }
-        final ItemStack current = inv.getItemInHand();
-        final ItemStack newItem = event.getCursor();
-        final ItemMeta newMeta = newItem.getItemMeta();
-        final ItemMeta oldMeta = newItem.getItemMeta();
+        ItemStack current = inv.getItemInHand();
+        ItemStack newItem = event.getCursor();
+        ItemMeta newMeta = newItem.getItemMeta();
+        ItemMeta oldMeta = newItem.getItemMeta();
         String newLore = "";
         if (newMeta != null) {
-            final List<String> lore = newMeta.getLore();
+            List<String> lore = newMeta.getLore();
             if (lore != null) {
                 newLore = lore.toString();
             }
         }
         String oldLore = "";
         if (oldMeta != null) {
-            final List<String> lore = oldMeta.getLore();
+            List<String> lore = oldMeta.getLore();
             if (lore != null) {
                 oldLore = lore.toString();
             }
@@ -69,86 +69,82 @@ public class PlayerEvents_1_8 extends PlotListener implements Listener {
         if (!newLore.equals("[(+NBT)]") || (current.equals(newItem) && newLore.equals(oldLore))) {
             return;
         }
-        final HashSet<Byte> blocks = null;
-        final Block block = player.getTargetBlock(blocks, 7);
-        final BlockState state = block.getState();
+        HashSet<Byte> blocks = null;
+        Block block = player.getTargetBlock(blocks, 7);
+        BlockState state = block.getState();
         if (state == null) {
             return;
         }
         if (state.getType() != newItem.getType()) {
             return;
         }
-        final Location l = BukkitUtil.getLocation(state.getLocation());
+        Location l = BukkitUtil.getLocation(state.getLocation());
         PlotArea area = l.getPlotArea();
         if (area == null) {
             return;
         }
-        final Plot plot = area.getPlotAbs(l);
-        final PlotPlayer pp = BukkitUtil.getPlayer(player);
+        Plot plot = area.getPlotAbs(l);
+        PlotPlayer pp = BukkitUtil.getPlayer(player);
         boolean cancelled = false;
         if (plot == null) {
             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");
+            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 {
-                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;
-                    }
-                }
             }
         }
         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) {
-        final Entity entity = e.getRightClicked();
+    public void onInteract(PlayerInteractAtEntityEvent e) {
+        Entity entity = e.getRightClicked();
         if (!(entity instanceof ArmorStand)) {
             return;
         }
-        final Location l = BukkitUtil.getLocation(e.getRightClicked().getLocation());
-        final PlotArea area = l.getPlotArea();
+        Location l = BukkitUtil.getLocation(e.getRightClicked().getLocation());
+        PlotArea area = l.getPlotArea();
         if (area == null) {
             return;
         }
-        final Plot plot = area.getPlotAbs(l);
-        final PlotPlayer pp = BukkitUtil.getPlayer(e.getPlayer());
+        Plot plot = area.getPlotAbs(l);
+        PlotPlayer pp = BukkitUtil.getPlayer(e.getPlayer());
         if (plot == null) {
             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");
+            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 {
-                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);
-                    }
-                }
             }
         }
     }

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

@@ -1,50 +0,0 @@
-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 PlayerEvents_1_8_3 implements Listener {
-    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onBigBoom(final BlockExplodeEvent event) {
-        final Block block = event.getBlock();
-        Location loc = BukkitUtil.getLocation(block.getLocation());
-        final String world = loc.getWorld();
-        if (!PS.get().hasPlotArea(world)) {
-            return;
-        }
-        PlotArea area = loc.getPlotArea();
-        if (area == null) {
-            final Iterator<Block> iter = event.blockList().iterator();
-            while (iter.hasNext()) {
-                loc = BukkitUtil.getLocation(iter.next().getLocation());
-                if (loc.getPlotArea() != null) {
-                    iter.remove();
-                }
-            }
-            return;
-        }
-        Plot plot = area.getOwnedPlot(loc);
-        if (plot == null || !FlagManager.isPlotFlagTrue(plot, "explosion")) {
-            event.setCancelled(true);
-        }
-        final Iterator<Block> iter = event.blockList().iterator();
-        while (iter.hasNext()) {
-            final Block b = iter.next();
-            if (!plot.equals(area.getOwnedPlot(BukkitUtil.getLocation(b.getLocation())))) {
-                iter.remove();
-            }
-        }
-        return;
-    }
-}

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

@@ -0,0 +1,31 @@
+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;
+
+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

@@ -1,84 +1,55 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// 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.listeners;
 
-import com.intellectualcrafters.plot.flag.Flag;
-import com.intellectualcrafters.plot.flag.FlagManager;
+import com.google.common.base.Optional;
+import com.intellectualcrafters.plot.flag.Flags;
 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 java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map.Entry;
+import java.util.UUID;
 import org.bukkit.Bukkit;
 import org.bukkit.GameMode;
-import org.bukkit.Material;
-import org.bukkit.block.BlockState;
+import org.bukkit.block.Block;
 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.BlockBreakEvent;
 import org.bukkit.event.block.BlockDamageEvent;
-import org.bukkit.event.block.BlockFadeEvent;
 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.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map.Entry;
-import java.util.UUID;
-
-/**
- * Created 2014-10-30 for PlotSquared
- *
-
- */
-@SuppressWarnings({ "deprecation" })
 public class PlotPlusListener extends PlotListener implements Listener {
-    private final static HashMap<String, Interval> feedRunnable = new HashMap<>();
-    private final static HashMap<String, Interval> healRunnable = new HashMap<>();
-    
-    public static void startRunnable(final JavaPlugin plugin) {
+
+    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 (final Iterator<Entry<String, Interval>> iter = healRunnable.entrySet().iterator(); iter.hasNext();) {
-                        final Entry<String, Interval> entry = iter.next();
-                        final Interval value = entry.getValue();
+                    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;
-                            final Player player = Bukkit.getPlayer(entry.getKey());
+                            Player player = Bukkit.getPlayer(entry.getKey());
                             if (player == null) {
-                                iter.remove();
+                                iterator.remove();
                                 continue;
                             }
-                            final double level = player.getHealth();
+                            double level = player.getHealth();
                             if (level != value.max) {
                                 player.setHealth(Math.min(level + value.amount, value.max));
                             }
@@ -86,18 +57,18 @@ public class PlotPlusListener extends PlotListener implements Listener {
                     }
                 }
                 if (!feedRunnable.isEmpty()) {
-                    for (final Iterator<Entry<String, Interval>> iter = feedRunnable.entrySet().iterator(); iter.hasNext();) {
-                        final Entry<String, Interval> entry = iter.next();
-                        final Interval value = entry.getValue();
+                    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;
-                            final Player player = Bukkit.getPlayer(entry.getKey());
+                            Player player = Bukkit.getPlayer(entry.getKey());
                             if (player == null) {
-                                iter.remove();
+                                iterator.remove();
                                 continue;
                             }
-                            final int level = player.getFoodLevel();
+                            int level = player.getFoodLevel();
                             if (level != value.max) {
                                 player.setFoodLevel(Math.min(level + value.amount, value.max));
                             }
@@ -105,165 +76,123 @@ public class PlotPlusListener extends PlotListener implements Listener {
                     }
                 }
             }
-        }, 0l, 20l);
+        }, 0L, 20L);
     }
 
     @EventHandler(priority = EventPriority.HIGH)
-    public void onMelt(final BlockFadeEvent event) {
-        final BlockState state = event.getNewState();
-
-        if (state.getType() != Material.WATER && state.getType() != Material.STATIONARY_WATER) {
-            return;
-        }
-        final Plot plot = BukkitUtil.getLocation(state.getLocation()).getOwnedPlot();
-        if (plot == null) {
-            return;
-        }
-        if (!FlagManager.isBooleanFlag(plot, "ice-melt", false)) {
-            event.setCancelled(true);
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGH)
-    public void onInteract(final BlockDamageEvent event) {
-        final Player player = event.getPlayer();
+    public void onInteract(BlockDamageEvent event) {
+        Player player = event.getPlayer();
         if (player.getGameMode() != GameMode.SURVIVAL) {
             return;
         }
-        final Plot plot = BukkitUtil.getLocation(player).getOwnedPlot();
+        Plot plot = BukkitUtil.getLocation(player).getOwnedPlot();
         if (plot == null) {
             return;
         }
-        if (FlagManager.isBooleanFlag(plot, "instabreak", false)) {
-            event.getBlock().breakNaturally();
+        if (Flags.INSTABREAK.isTrue(plot)) {
+            Block block = event.getBlock();
+            BlockBreakEvent call = new BlockBreakEvent(block, player);
+            Bukkit.getServer().getPluginManager().callEvent(call);
+            if (!call.isCancelled()) {
+                event.getBlock().breakNaturally();
+            }
         }
     }
     
     @EventHandler(priority = EventPriority.HIGH)
-    public void onDamage(final EntityDamageEvent event) {
+    public void onDamage(EntityDamageEvent event) {
         if (event.getEntityType() != EntityType.PLAYER) {
             return;
         }
-        final Player player = (Player) event.getEntity();
-        final Plot plot = BukkitUtil.getLocation(player).getOwnedPlot();
+        Player player = (Player) event.getEntity();
+        Plot plot = BukkitUtil.getLocation(player).getOwnedPlot();
         if (plot == null) {
             return;
         }
-        if (FlagManager.isBooleanFlag(plot, "invincible", false)) {
+        if (Flags.INVINCIBLE.isTrue(plot)) {
             event.setCancelled(true);
         }
     }
     
     @EventHandler
-    public void onItemPickup(final PlayerPickupItemEvent event) {
-        final Player player = event.getPlayer();
-        final PlotPlayer pp = BukkitUtil.getPlayer(player);
-        final Plot plot = BukkitUtil.getLocation(player).getOwnedPlot();
+    public void onItemPickup(PlayerPickupItemEvent event) {
+        Player player = event.getPlayer();
+        PlotPlayer pp = BukkitUtil.getPlayer(player);
+        Plot plot = BukkitUtil.getLocation(player).getOwnedPlot();
         if (plot == null) {
             return;
         }
-        final UUID uuid = pp.getUUID();
-        if (plot.isAdded(uuid) && FlagManager.isBooleanFlag(plot, "drop-protection", false)) {
+        UUID uuid = pp.getUUID();
+        if (plot.isAdded(uuid) && Flags.DROP_PROTECTION.isTrue(plot)) {
             event.setCancelled(true);
         }
     }
     
     @EventHandler
-    public void onItemDrop(final PlayerDropItemEvent event) {
-        final Player player = event.getPlayer();
-        final PlotPlayer pp = BukkitUtil.getPlayer(player);
-        final Plot plot = BukkitUtil.getLocation(player).getOwnedPlot();
+    public void onItemDrop(PlayerDropItemEvent event) {
+        Player player = event.getPlayer();
+        PlotPlayer pp = BukkitUtil.getPlayer(player);
+        Plot plot = BukkitUtil.getLocation(player).getOwnedPlot();
         if (plot == null) {
             return;
         }
-        final UUID uuid = pp.getUUID();
-        if (plot.isAdded(uuid) && FlagManager.isBooleanFlag(plot, "item-drop", false)) {
-            event.setCancelled(true);
+        UUID uuid = pp.getUUID();
+        if (!plot.isAdded(uuid)) {
+            if (Flags.ITEM_DROP.isFalse(plot)) {
+                event.setCancelled(true);
+            }
         }
     }
     
     @EventHandler
-    public void onPlotEnter(final PlayerEnterPlotEvent event) {
-        final Player player = event.getPlayer();
-        final Plot plot = event.getPlot();
-        final Flag feed = FlagManager.getPlotFlagRaw(plot, "feed");
-        if (feed != null) {
-            final Integer[] value = (Integer[]) feed.getValue();
+    public void onPlotEnter(PlayerEnterPlotEvent event) {
+        Player player = event.getPlayer();
+        Plot plot = event.getPlot();
+        Optional<Integer[]> feed = plot.getFlag(Flags.FEED);
+        if (feed.isPresent()) {
+            Integer[] value = feed.get();
             feedRunnable.put(player.getName(), new Interval(value[0], value[1], 20));
         }
-        final Flag heal = FlagManager.getPlotFlagRaw(plot, "heal");
-        if (heal != null) {
-            final Integer[] value = (Integer[]) heal.getValue();
+        Optional<Integer[]> heal = plot.getFlag(Flags.HEAL);
+        if (heal.isPresent()) {
+            Integer[] value = heal.get();
             healRunnable.put(player.getName(), new Interval(value[0], value[1], 20));
         }
     }
     
     @EventHandler
-    public void onPlayerQuit(final PlayerQuitEvent event) {
-        final Player player = event.getPlayer();
-        final String name = player.getName();
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        Player player = event.getPlayer();
+        String name = player.getName();
         feedRunnable.remove(name);
         healRunnable.remove(name);
     }
     
     @EventHandler
-    public void onPlotLeave(final PlayerLeavePlotEvent event) {
-        final Player leaver = event.getPlayer();
-        final Plot plot = event.getPlot();
+    public void onPlotLeave(PlayerLeavePlotEvent event) {
+        Player leaver = event.getPlayer();
+        Plot plot = event.getPlot();
         if (!plot.hasOwner()) {
             return;
         }
         BukkitUtil.getPlayer(leaver);
-        final String name = leaver.getName();
+        String name = leaver.getName();
         feedRunnable.remove(name);
         healRunnable.remove(name);
     }
-    
-    public static class Interval {
-        public final int interval;
-        public final int amount;
-        public final int max;
+
+    private static class Interval {
+
+        final int interval;
+        final int amount;
+        final int max;
         public int count = 0;
-        
-        public Interval(final int interval, final int amount, final int max) {
+
+        Interval(int interval, int amount, int max) {
             this.interval = interval;
             this.amount = amount;
             this.max = max;
         }
     }
-    
-    /**
-     * Record Meta Class
-     *
 
-     */
-    public static class RecordMeta {
-        public final static List<RecordMeta> metaList = new ArrayList<>();
-        static {
-            for (int x = 3; x < 12; x++) {
-                metaList.add(new RecordMeta(x + "", Material.valueOf("RECORD_" + x)));
-            }
-        }
-        private final String name;
-        private final Material material;
-        
-        public RecordMeta(final String name, final Material material) {
-            this.name = name;
-            this.material = material;
-        }
-        
-        @Override
-        public String toString() {
-            return name;
-        }
-        
-        @Override
-        public int hashCode() {
-            return name.hashCode();
-        }
-        
-        public Material getMaterial() {
-            return material;
-        }
-    }
 }

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

@@ -1,5 +1,8 @@
 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;
@@ -7,17 +10,13 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.world.WorldInitEvent;
 import org.bukkit.generator.ChunkGenerator;
 
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.generator.GeneratorWrapper;
-import com.plotsquared.bukkit.generator.BukkitPlotGenerator;
-
 public class WorldEvents implements Listener {
     
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public static void onWorldInit(final WorldInitEvent event) {
-        final World world = event.getWorld();
-        final String name = world.getName();
-        final ChunkGenerator gen = world.getGenerator();
+    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 {

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

@@ -1,337 +0,0 @@
-package com.plotsquared.bukkit.listeners.worldedit;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-
-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 com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.config.C;
-import com.intellectualcrafters.plot.config.Settings;
-import com.intellectualcrafters.plot.object.Plot;
-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;
-
-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> 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<>(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<>(Collections.singletonList("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<>(Collections.singletonList("up"));
-    public final HashSet<String> other = new HashSet<>(Arrays.asList("undo", "redo"));
-    
-    public boolean checkCommand(final List<String> list, final String cmd) {
-        for (final String identifier : list) {
-            if (("/" + identifier).equals(cmd) || ("//" + identifier).equals(cmd) || ("/worldedit:/" + identifier).equals(cmd) || ("/worldedit:" + identifier).equals(cmd)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    
-    public String reduceCmd(final String cmd, final boolean single) {
-        if (cmd.startsWith("/worldedit:/")) {
-            return cmd.substring(12);
-        }
-        if (cmd.startsWith("/worldedit:")) {
-            return cmd.substring(11);
-        }
-        if (cmd.startsWith("//")) {
-            return cmd.substring(2);
-        }
-        if (single && cmd.startsWith("/")) {
-            return cmd.substring(1);
-        }
-        return cmd;
-    }
-    
-    public int getInt(final String s) {
-        try {
-            int max = 0;
-            final String[] split = s.split(",");
-            for (final String rad : split) {
-                final int val = Integer.parseInt(rad);
-                if (val > max) {
-                    max = val;
-                }
-            }
-            return max;
-        } catch (final NumberFormatException e) {
-            return 0;
-        }
-    }
-    
-    public boolean checkVolume(final PlotPlayer player, final long volume, final long max, final Cancellable e) {
-        if (volume > max) {
-            MainUtil.sendMessage(player, C.WORLDEDIT_VOLUME.s().replaceAll("%current%", volume + "").replaceAll("%max%", max + ""));
-            e.setCancelled(true);
-        }
-        if (Permissions.hasPermission(player, "plots.worldedit.bypass")) {
-            MainUtil.sendMessage(player, C.WORLDEDIT_BYPASS);
-        }
-        return true;
-    }
-    
-    public boolean checkSelection(final Player p, final PlotPlayer pp, final int modifier, final long max, final Cancellable e) {
-        final Selection selection = BukkitMain.worldEdit.getSelection(p);
-        if (selection == null) {
-            return true;
-        }
-        final BlockVector pos1 = selection.getNativeMinimumPoint().toBlockVector();
-        final BlockVector pos2 = selection.getNativeMaximumPoint().toBlockVector();
-        final HashSet<RegionWrapper> mask = WEManager.getMask(pp);
-        final 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.getBlockY(), pos1.getBlockZ())) {
-                arg = "pos1";
-            } else if (!WEManager.maskContains(mask, pos2.getBlockX(), pos2.getBlockY(), pos2.getBlockZ())) {
-                arg = "pos2";
-            }
-            if (arg != null) {
-                e.setCancelled(true);
-                MainUtil.sendMessage(pp, C.REQUIRE_SELECTION_IN_MASK, arg);
-                if (Permissions.hasPermission(pp, "plots.worldedit.bypass")) {
-                    MainUtil.sendMessage(pp, C.WORLDEDIT_BYPASS);
-                }
-                return true;
-            }
-            if (!WEManager.regionContains(region, mask)) {
-                MainUtil.sendMessage(pp, C.REQUIRE_SELECTION_IN_MASK, "pos1 + pos2");
-                e.setCancelled(true);
-                if (Permissions.hasPermission(pp, "plots.worldedit.bypass")) {
-                    MainUtil.sendMessage(pp, C.WORLDEDIT_BYPASS);
-                }
-                return true;
-            }
-        }
-        final 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, final boolean delayed) {
-        if (!Settings.QUEUE_COMMANDS || !Settings.EXPERIMENTAL_FAST_ASYNC_WORLDEDIT) {
-            return false;
-        }
-        final 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 WorldEditPlugin worldedit = BukkitMain.worldEdit;
-        if (worldedit == null) {
-            HandlerList.unregisterAll(this);
-            return true;
-        }
-        final Player p = e.getPlayer();
-        final PlotPlayer pp = BukkitUtil.getPlayer(p);
-        if (!PS.get().hasPlotArea(p.getWorld().getName())) {
-            return true;
-        }
-        final String message = e.getMessage();
-        final String cmd = message.toLowerCase();
-        final boolean single = true;
-        final String[] split = cmd.split(" ");
-        
-        final long maxVolume = Settings.WE_MAX_VOLUME;
-        final long maxIterations = Settings.WE_MAX_ITERATIONS;
-        if (pp.getAttribute("worldedit")) {
-            return true;
-        }
-        if (split.length >= 2) {
-            final String reduced = reduceCmd(split[0], single);
-            final String reduced2 = reduceCmd(split[0] + " " + split[1], single);
-            if (rad1.contains(reduced)) {
-                if (delay(p, message, false)) {
-                    e.setCancelled(true);
-                    return true;
-                }
-                final long volume = getInt(split[1]) * 256;
-                return checkVolume(pp, volume, maxVolume, e);
-            }
-            if (rad2.contains(reduced)) {
-                if (delay(p, message, false)) {
-                    e.setCancelled(true);
-                    return true;
-                }
-                if (split.length >= 3) {
-                    final long volume = getInt(split[2]) * 256;
-                    return checkVolume(pp, volume, maxVolume, e);
-                }
-                return true;
-            }
-            if (rad2_1.contains(reduced)) {
-                if (delay(p, message, false)) {
-                    e.setCancelled(true);
-                    return true;
-                }
-                if (split.length >= 4) {
-                    final long volume = getInt(split[2]) * getInt(split[3]);
-                    return checkVolume(pp, volume, maxVolume, e);
-                }
-                return true;
-            }
-            if (rad2_2.contains(reduced)) {
-                if (delay(p, message, false)) {
-                    e.setCancelled(true);
-                    return true;
-                }
-                if (split.length >= 3) {
-                    final long radius = getInt(split[2]);
-                    final long volume = radius * radius;
-                    return checkVolume(pp, volume, maxVolume, e);
-                }
-                return true;
-            }
-            if (rad2_3.contains(reduced2)) {
-                if (delay(p, message, false)) {
-                    e.setCancelled(true);
-                    return true;
-                }
-                if (split.length >= 3) {
-                    if (split.length == 4) {
-                        final int iterations = getInt(split[3]);
-                        if (iterations > 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);
-                            }
-                            return true;
-                        }
-                    }
-                    final long radius = getInt(split[2]);
-                    final long volume = radius * radius;
-                    return checkVolume(pp, volume, maxVolume, e);
-                }
-                return true;
-            }
-            if (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")) {
-                        i = 3;
-                    }
-                    final long radius = getInt(split[i]);
-                    final long volume = radius * radius;
-                    return checkVolume(pp, volume, maxVolume, e);
-                }
-                return true;
-            }
-            if (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")) {
-                        i = 4;
-                    }
-                    final long radius = getInt(split[i]);
-                    final long volume = radius * radius;
-                    return checkVolume(pp, volume, maxVolume, e);
-                }
-                return true;
-            }
-            if (regionExtend.contains(reduced)) {
-                if (delay(p, message, false)) {
-                    e.setCancelled(true);
-                    return true;
-                }
-                return checkSelection(p, pp, getInt(split[1]), maxVolume, e);
-            }
-        }
-        final String reduced = reduceCmd(split[0], single);
-        if (Settings.WE_BLACKLIST.contains(reduced)) {
-            MainUtil.sendMessage(pp, C.WORLDEDIT_UNSAFE);
-            e.setCancelled(true);
-            if (Permissions.hasPermission(pp, "plots.worldedit.bypass")) {
-                MainUtil.sendMessage(pp, C.WORLDEDIT_BYPASS);
-            }
-        }
-        if (restricted.contains(reduced)) {
-            final 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);
-            MainUtil.sendMessage(pp, C.NO_PLOT_PERMS);
-            if (Permissions.hasPermission(pp, "plots.worldedit.bypass")) {
-                MainUtil.sendMessage(pp, C.WORLDEDIT_BYPASS);
-            }
-            return true;
-        }
-        if (region.contains(reduced)) {
-            if (delay(p, message, false)) {
-                e.setCancelled(true);
-                return true;
-            }
-            return checkSelection(p, pp, 1, maxVolume, e);
-        }
-        if (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,40 +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;
     private Block block;
     private PlotBlock pb;
-    
-    public BukkitLazyBlock(final int id, final Block block) {
+
+    public BukkitLazyBlock(int id, Block block) {
         this.id = id;
         this.block = block;
     }
-    
-    public BukkitLazyBlock(final PlotBlock pb) {
-        id = pb.id;
+
+    public BukkitLazyBlock(PlotBlock pb) {
+        this.id = pb.id;
         this.pb = pb;
     }
-    
-    public BukkitLazyBlock(final Block block) {
+
+    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 == 0) {
-            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:
@@ -120,20 +119,20 @@ public class BukkitLazyBlock extends LazyBlock {
                 data = 0;
                 break;
             default:
-                data = block.getData();
+                data = this.block.getData();
                 break;
         }
-        pb = new PlotBlock((short) id, data);
-        return pb;
-        
+        this.pb = PlotBlock.get((short) this.id, data);
+        return this.pb;
+
     }
-    
+
     @Override
     public int getId() {
-        if (id == 0) {
-            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,40 +1,41 @@
 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.
+     * Please do not use this method. Instead use BukkitUtil.getPlayer(Player),
+     * as it caches player objects.
+     *
      * @param player
      */
-    public BukkitOfflinePlayer(final OfflinePlayer player) {
+    public BukkitOfflinePlayer(OfflinePlayer player) {
         this.player = player;
     }
-    
+
     @Override
     public UUID getUUID() {
-        return player.getUniqueId();
+        return this.player.getUniqueId();
     }
-    
+
     @Override
     public long getLastPlayed() {
-        return player.getLastPlayed();
+        return this.player.getLastPlayed();
     }
-    
+
     @Override
     public boolean isOnline() {
-        return player.isOnline();
+        return this.player.isOnline();
     }
-    
+
     @Override
     public String getName() {
-        return player.getName();
+        return this.player.getName();
     }
 }

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

@@ -1,21 +1,18 @@
 package com.plotsquared.bukkit.object;
 
-import com.intellectualcrafters.plot.config.C;
 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.PlotGameMode;
 import com.intellectualcrafters.plot.util.PlotWeather;
+import com.intellectualcrafters.plot.util.StringMan;
 import com.intellectualcrafters.plot.util.UUIDHandler;
 import com.plotsquared.bukkit.util.BukkitUtil;
-import org.bukkit.Bukkit;
 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 org.bukkit.permissions.Permission;
-import org.bukkit.plugin.PluginManager;
 
 import java.util.UUID;
 
@@ -25,205 +22,186 @@ public class BukkitPlayer extends PlotPlayer {
     public boolean offline;
     private UUID uuid;
     private String name;
-    private long last = 0;
-    
+
     /**
-     * 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 BukkitPlayer(final Player player) {
+    public BukkitPlayer(Player player) {
         this.player = player;
         super.populatePersistentMetaMap();
     }
-    
-    public BukkitPlayer(final Player player, final boolean offline) {
+
+    public BukkitPlayer(Player player, boolean offline) {
         this.player = player;
         this.offline = offline;
         super.populatePersistentMetaMap();
     }
-    
-    @Override
-    public long getPreviousLogin() {
-        if (last == 0) {
-            last = player.getLastPlayed();
-        }
-        return last;
-    }
-    
+
     @Override
     public Location getLocation() {
-        final Location loc = super.getLocation();
-        return loc == null ? BukkitUtil.getLocation(player) : loc;
+        Location location = super.getLocation();
+        return location == null ? BukkitUtil.getLocation(this.player) : location;
     }
     
     @Override
     public UUID getUUID() {
-        if (uuid == null) {
-            uuid = UUIDHandler.getUUID(this);
+        if (this.uuid == null) {
+            this.uuid = UUIDHandler.getUUID(this);
+        }
+        return this.uuid;
+    }
+
+    @Override public long getLastPlayed() {
+        return this.player.getLastPlayed();
+    }
+
+    @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) {
+        if (!StringMan.isEqual(this.<String>getMeta("lastMessage"), message) || (System.currentTimeMillis() - this.<Long>getMeta("lastMessageTime") > 5000)) {
+            setMeta("lastMessage", message);
+            setMeta("lastMessageTime", System.currentTimeMillis());
+            this.player.sendMessage(message);
         }
-        return uuid;
     }
     
     @Override
-    public boolean hasPermission(final String node) {
-        if (offline && EconHandler.manager != null) {
-            return EconHandler.manager.hasPermission(getName(), node);
-        }
-        return player.hasPermission(node);
-    }
-    
-    public Permission getPermission(final String node) {
-        final PluginManager manager = Bukkit.getPluginManager();
-        Permission perm = manager.getPermission(node);
-        if (perm == null) {
-            final String[] nodes = node.split("\\.");
-            perm = new Permission(node);
-            final StringBuilder n = new StringBuilder();
-            for (int i = 0; i < nodes.length - 1; i++) {
-                n.append(nodes[i]).append(".");
-                if (!node.equals(n + C.PERMISSION_STAR.s())) {
-                    final Permission parent = getPermission(n + C.PERMISSION_STAR.s());
-                    if (parent != null) {
-                        perm.addParent(parent, true);
-                    }
-                }
-            }
-            manager.addPermission(perm);
-        }
-        manager.recalculatePermissionDefaults(perm);
-        perm.recalculatePermissibles();
-        return perm;
-    }
-    
-    @Override
-    public void sendMessage(final String message) {
-        player.sendMessage(message);
-    }
-    
-    @Override
-    public void teleport(final Location loc) {
-        if (Math.abs(loc.getX()) >= 30000000 || Math.abs(loc.getZ()) >= 30000000) {
+    public void teleport(Location location) {
+        if (Math.abs(location.getX()) >= 30000000 || Math.abs(location.getZ()) >= 30000000) {
             return;
         }
-        player.teleport(new org.bukkit.Location(BukkitUtil.getWorld(loc.getWorld()), loc.getX() + 0.5, loc.getY(), loc.getZ() + 0.5, loc.getYaw(), loc.getPitch()), TeleportCause.COMMAND);
+        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 (name == null) {
-            name = player.getName();
+        if (this.name == null) {
+            this.name = this.player.getName();
         }
-        return name;
+        return this.name;
     }
     
     @Override
     public boolean isOnline() {
-        return !offline && player.isOnline();
+        return !this.offline && this.player.isOnline();
     }
     
     @Override
-    public void setCompassTarget(final Location loc) {
-        player.setCompassTarget(new org.bukkit.Location(BukkitUtil.getWorld(loc.getWorld()), loc.getX(), loc.getY(), loc.getZ()));
+    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(player);
+        return BukkitUtil.getLocationFull(this.player);
     }
-    
+
     @Override
-    public void loadData() {
-        if (!player.isOnline()) {
-            player.loadData();
-        }
-    }
-    
-    @Override
-    public void saveData() {
-        player.saveData();
-    }
-    
-    @Override
-    public void setWeather(final PlotWeather weather) {
+    public void setWeather(PlotWeather weather) {
         switch (weather) {
             case CLEAR:
-                player.setPlayerWeather(WeatherType.CLEAR);
-                return;
+                this.player.setPlayerWeather(WeatherType.CLEAR);
+                break;
             case RAIN:
-                player.setPlayerWeather(WeatherType.DOWNFALL);
-                return;
+                this.player.setPlayerWeather(WeatherType.DOWNFALL);
+                break;
             case RESET:
-                player.resetPlayerWeather();
-                return;
+                this.player.resetPlayerWeather();
+                break;
+            default:
+                this.player.resetPlayerWeather();
+                break;
         }
     }
     
     @Override
-    public PlotGamemode getGamemode() {
-        switch (player.getGameMode()) {
+    public PlotGameMode getGameMode() {
+        switch (this.player.getGameMode()) {
             case ADVENTURE:
-                return PlotGamemode.ADVENTURE;
+                return PlotGameMode.ADVENTURE;
             case CREATIVE:
-                return PlotGamemode.CREATIVE;
+                return PlotGameMode.CREATIVE;
             case SPECTATOR:
-                return PlotGamemode.SPECTATOR;
+                return PlotGameMode.SPECTATOR;
             case SURVIVAL:
-                return PlotGamemode.SURVIVAL;
+                return PlotGameMode.SURVIVAL;
+            default:
+                return PlotGameMode.NOT_SET;
         }
-        return null;
     }
     
     @Override
-    public void setGamemode(final PlotGamemode gamemode) {
-        switch (gamemode) {
+    public void setGameMode(PlotGameMode gameMode) {
+        switch (gameMode) {
             case ADVENTURE:
-                player.setGameMode(GameMode.ADVENTURE);
-                return;
+                this.player.setGameMode(GameMode.ADVENTURE);
+                break;
             case CREATIVE:
-                player.setGameMode(GameMode.CREATIVE);
-                return;
+                this.player.setGameMode(GameMode.CREATIVE);
+                break;
             case SPECTATOR:
-                player.setGameMode(GameMode.SPECTATOR);
-                return;
+                this.player.setGameMode(GameMode.SPECTATOR);
+                break;
             case SURVIVAL:
-                player.setGameMode(GameMode.SURVIVAL);
-                return;
+                this.player.setGameMode(GameMode.SURVIVAL);
+                break;
+            default:
+                this.player.setGameMode(GameMode.SURVIVAL);
+                break;
         }
     }
     
     @Override
-    public void setTime(final long time) {
+    public void setTime(long time) {
         if (time != Long.MAX_VALUE) {
-            player.setPlayerTime(time, false);
+            this.player.setPlayerTime(time, false);
         } else {
-            player.resetPlayerTime();
+            this.player.resetPlayerTime();
         }
     }
     
     @Override
-    public void setFlight(final boolean fly) {
-        player.setAllowFlight(fly);
+    public void setFlight(boolean fly) {
+        this.player.setAllowFlight(fly);
+    }
+
+    @Override
+    public boolean getFlight() {
+        return player.getAllowFlight();
+    }
+
+    @Override
+    public void playMusic(Location location, int id) {
+        //noinspection deprecation
+        this.player.playEffect(BukkitUtil.getLocation(location), Effect.RECORD_PLAY, id);
     }
     
     @Override
-    public void playMusic(final Location loc, final int id) {
-        player.playEffect(BukkitUtil.getLocation(loc), Effect.RECORD_PLAY, id);
-    }
-    
-    @Override
-    public void kick(final String message) {
-        player.kickPlayer(message);
+    public void kick(String message) {
+        this.player.kickPlayer(message);
     }
 
     @Override public void stopSpectating() {
-        if (getGamemode() == PlotGamemode.SPECTATOR) {
-            player.setSpectatorTarget(null);
+        if (getGameMode() == PlotGameMode.SPECTATOR) {
+            this.player.setSpectatorTarget(null);
         }
     }
 
     @Override
     public boolean isBanned() {
-        return player.isBanned();
+        return this.player.isBanned();
     }
 }

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

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

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

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

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

@@ -1,12 +1,13 @@
 package com.plotsquared.bukkit.object.entity;
 
 
-public class EntityBaseStats {
-    public EntityWrapper passenger;
-    public float fall;
-    public short fire;
-    public int age;
-    public double v_z;
-    public double v_y;
-    public double v_x;
+class EntityBaseStats {
+
+    EntityWrapper passenger;
+    float fall;
+    short fire;
+    int age;
+    double vZ;
+    double vY;
+    double vX;
 }

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

@@ -5,17 +5,19 @@ import org.bukkit.Art;
 import org.bukkit.DyeColor;
 import org.bukkit.Location;
 import org.bukkit.Rotation;
+import org.bukkit.TreeSpecies;
 import org.bukkit.World;
 import org.bukkit.block.BlockFace;
 import org.bukkit.entity.Ageable;
 import org.bukkit.entity.ArmorStand;
+import org.bukkit.entity.Bat;
+import org.bukkit.entity.Boat;
+import org.bukkit.entity.EnderDragon;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Guardian;
 import org.bukkit.entity.Horse;
-import org.bukkit.entity.Horse.Color;
-import org.bukkit.entity.Horse.Style;
-import org.bukkit.entity.Horse.Variant;
+import org.bukkit.entity.IronGolem;
 import org.bukkit.entity.Item;
 import org.bukkit.entity.ItemFrame;
 import org.bukkit.entity.LivingEntity;
@@ -25,6 +27,7 @@ import org.bukkit.entity.Rabbit.Type;
 import org.bukkit.entity.Sheep;
 import org.bukkit.entity.Skeleton;
 import org.bukkit.entity.Skeleton.SkeletonType;
+import org.bukkit.entity.Slime;
 import org.bukkit.entity.Tameable;
 import org.bukkit.inventory.EntityEquipment;
 import org.bukkit.inventory.InventoryHolder;
@@ -34,60 +37,67 @@ import org.bukkit.util.Vector;
 
 public class EntityWrapper {
 
-    public EntityType type;
-    public float yaw;
-    public float pitch;
+    private final EntityType type;
+    private final float yaw;
+    private final float pitch;
+    private final short depth;
+    private final int hash;
+    private final EntityBaseStats base = new EntityBaseStats();
     public double x;
     public double y;
     public double z;
-    public short depth;
-    public EntityBaseStats base = null;
-    // Extended
-    public ItemStack stack;
     public ItemStack[] inventory;
-    public byte dataByte;
-    public byte dataByte2;
-    public String dataString;
-    public LivingEntityStats lived;
-    public AgeableStats aged;
-    public TameableStats tamed;
-    private HorseStats horse;
+    // Extended
+    private ItemStack stack;
+    private byte dataByte;
+    private byte dataByte2;
+    private String dataString;
+    private LivingEntityStats lived;
+    private AgeableStats aged;
+    private TameableStats tamed;
     private ArmorStandStats stand;
-    
-    private int hash;
-    
-    @SuppressWarnings("deprecation")
-    public EntityWrapper(final org.bukkit.entity.Entity entity, final short depth) {
-        hash = entity.getEntityId();
+    private HorseStats horse;
+    private boolean noGravity;
+
+    public EntityWrapper(Entity entity, short depth) {
+        this.hash = entity.getEntityId();
         this.depth = depth;
-        final Location loc = entity.getLocation();
-        yaw = loc.getYaw();
-        pitch = loc.getPitch();
-        x = loc.getX();
-        y = loc.getY();
-        z = loc.getZ();
-        type = entity.getType();
+        Location location = entity.getLocation();
+        this.yaw = location.getYaw();
+        this.pitch = location.getPitch();
+        this.x = location.getX();
+        this.y = location.getY();
+        this.z = location.getZ();
+        this.type = entity.getType();
         if (depth == 0) {
             return;
         }
-        base = new EntityBaseStats();
-        final Entity p = entity.getPassenger();
-        if (p != null) {
-            base.passenger = new EntityWrapper(p, depth);
+        Entity passenger = entity.getPassenger();
+        if (passenger != null) {
+            this.base.passenger = new EntityWrapper(passenger, depth);
         }
-        base.fall = entity.getFallDistance();
-        base.fire = (short) entity.getFireTicks();
-        base.age = entity.getTicksLived();
-        final Vector velocity = entity.getVelocity();
-        base.v_x = velocity.getX();
-        base.v_y = velocity.getY();
-        base.v_z = velocity.getZ();
+        this.base.fall = entity.getFallDistance();
+        this.base.fire = (short) entity.getFireTicks();
+        this.base.age = entity.getTicksLived();
+        Vector velocity = entity.getVelocity();
+        this.base.vX = velocity.getX();
+        this.base.vY = velocity.getY();
+        this.base.vZ = velocity.getZ();
         if (depth == 1) {
             return;
         }
+        if (PS.get().checkVersion(PS.get().IMP.getServerVersion(), 1, 10, 0) || entity instanceof ArmorStand) {
+            if (!entity.hasGravity()) {
+                this.noGravity = true;
+            }
+        }
         switch (entity.getType()) {
             case ARROW:
             case BOAT:
+                if (PS.get().checkVersion(PS.get().IMP.getServerVersion(), 1, 9, 0)) {
+                    Boat boat = (Boat) entity;
+                    this.dataByte = getOrdinal(TreeSpecies.values(), boat.getWoodType());
+                }
             case COMPLEX_PART:
             case EGG:
             case ENDER_CRYSTAL:
@@ -114,146 +124,137 @@ 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;
-                stack = item.getItemStack();
+            case DROPPED_ITEM:
+                Item item = (Item) entity;
+                this.stack = item.getItemStack();
                 return;
-            }
-            case ITEM_FRAME: {
-                final ItemFrame itemframe = (ItemFrame) entity;
-                x = Math.floor(x);
-                y = Math.floor(y);
-                z = Math.floor(z);
-                dataByte = getOrdinal(Rotation.values(), itemframe.getRotation());
-                stack = itemframe.getItem().clone();
+            case ITEM_FRAME:
+                this.x = Math.floor(this.x);
+                this.y = Math.floor(this.y);
+                this.z = Math.floor(this.z);
+                ItemFrame itemFrame = (ItemFrame) entity;
+                this.dataByte = getOrdinal(Rotation.values(), itemFrame.getRotation());
+                this.stack = itemFrame.getItem().clone();
                 return;
-            }
-            case PAINTING: {
-                final Painting painting = (Painting) entity;
-                x = Math.floor(x);
-                y = Math.floor(y);
-                z = Math.floor(z);
-                final Art a = painting.getArt();
-                dataByte = getOrdinal(BlockFace.values(), painting.getFacing());
-                final int h = a.getBlockHeight();
-                if ((h % 2) == 0) {
-                    y -= 1;
+            case PAINTING:
+                this.x = Math.floor(this.x);
+                this.y = Math.floor(this.y);
+                this.z = Math.floor(this.z);
+                Painting painting = (Painting) entity;
+                Art art = painting.getArt();
+                this.dataByte = getOrdinal(BlockFace.values(), painting.getFacing());
+                int h = art.getBlockHeight();
+                if (h % 2 == 0) {
+                    this.y -= 1;
                 }
-                dataString = a.name();
+                this.dataString = art.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();
-                this.horse.variant = getOrdinal(Variant.values(), horse.getVariant());
-                this.horse.style = getOrdinal(Style.values(), horse.getStyle());
-                this.horse.color = getOrdinal(Color.values(), horse.getColor());
-                storeTameable((Tameable) entity);
-                storeAgeable((Ageable) entity);
-                storeLiving((LivingEntity) entity);
-                storeInventory((InventoryHolder) entity);
+                this.horse.variant = horse.getVariant();
+                this.horse.style = horse.getStyle();
+                this.horse.color = horse.getColor();
+                storeTameable(horse);
+                storeAgeable(horse);
+                storeLiving(horse);
+                storeInventory(horse);
                 return;
-            }
             // END INVENTORY HOLDER //
             case WOLF:
-            case OCELOT: {
+            case OCELOT:
                 storeTameable((Tameable) entity);
                 storeAgeable((Ageable) entity);
                 storeLiving((LivingEntity) entity);
                 return;
-            }
-            // END AMEABLE //
-            case SHEEP: {
-                final Sheep sheep = (Sheep) entity;
-                dataByte = (byte) ((sheep).isSheared() ? 1 : 0);
-                dataByte2 = sheep.getColor().getDyeData();
-                storeAgeable((Ageable) entity);
-                storeLiving((LivingEntity) entity);
+            // END TAMEABLE //
+            case SHEEP:
+                Sheep sheep = (Sheep) entity;
+                this.dataByte = (byte) (sheep.isSheared() ? 1 : 0);
+                this.dataByte2 = sheep.getColor().getDyeData();
+                storeAgeable(sheep);
+                storeLiving(sheep);
                 return;
-            }
             case VILLAGER:
             case CHICKEN:
             case COW:
             case MUSHROOM_COW:
-            case PIG: {
+            case PIG:
+            case POLAR_BEAR:
+                storeAgeable((Ageable) entity);
+                storeLiving((LivingEntity) entity);
+                return;
+            case RABBIT:
+                this.dataByte = getOrdinal(Type.values(), ((Rabbit) entity).getRabbitType());
                 storeAgeable((Ageable) entity);
                 storeLiving((LivingEntity) entity);
                 return;
-            }
             // END AGEABLE //
-            case RABBIT: { // NEW
-                dataByte = getOrdinal(Type.values(), ((Rabbit) entity).getRabbitType());
-                storeAgeable((Ageable) entity);
+            case GUARDIAN:
+                this.dataByte = (byte) (((Guardian) entity).isElder() ? 1 : 0);
                 storeLiving((LivingEntity) entity);
                 return;
-            }
-            case GUARDIAN: { // NEW
-                dataByte = (byte) (((Guardian) entity).isElder() ? 1 : 0);
+            case SKELETON:
+                this.dataByte = getOrdinal(SkeletonType.values(),((Skeleton)entity).getSkeletonType());
                 storeLiving((LivingEntity) entity);
                 return;
-            }
-            case SKELETON: { // NEW
-                dataByte = (byte) ((Skeleton) entity).getSkeletonType().getId();
-                storeLiving((LivingEntity) entity);
-                return;
-            }
-            case ARMOR_STAND: { // NEW
-                                // CHECK positions
-                final ArmorStand stand = (ArmorStand) entity;
-                inventory = new ItemStack[] { stand.getItemInHand().clone(), stand.getHelmet().clone(), stand.getChestplate().clone(), stand.getLeggings().clone(), stand.getBoots().clone() };
-                storeLiving((LivingEntity) entity);
+            case ARMOR_STAND:
+                ArmorStand stand = (ArmorStand) entity;
+                this.inventory = new ItemStack[]{stand.getItemInHand().clone(), stand.getHelmet().clone(), stand.getChestplate().clone(),
+                        stand.getLeggings().clone(), stand.getBoots().clone()};
+                storeLiving(stand);
                 this.stand = new ArmorStandStats();
 
-                final EulerAngle head = stand.getHeadPose();
+                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();
 
-                final EulerAngle body = stand.getBodyPose();
+                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();
 
-                final EulerAngle leftLeg = stand.getLeftLegPose();
+                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();
 
-                final EulerAngle rightLeg = stand.getRightLegPose();
+                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();
 
-                final EulerAngle leftArm = stand.getLeftArmPose();
+                EulerAngle leftArm = stand.getLeftArmPose();
                 this.stand.leftArm[0] = (float) leftArm.getX();
                 this.stand.leftArm[1] = (float) leftArm.getY();
                 this.stand.leftArm[2] = (float) leftArm.getZ();
 
-                final EulerAngle rightArm = stand.getRightArmPose();
+                EulerAngle rightArm = stand.getRightArmPose();
                 this.stand.rightArm[0] = (float) rightArm.getX();
                 this.stand.rightArm[1] = (float) rightArm.getY();
                 this.stand.rightArm[2] = (float) rightArm.getZ();
@@ -262,10 +263,7 @@ public class EntityWrapper {
                     this.stand.arms = true;
                 }
                 if (!stand.hasBasePlate()) {
-                    this.stand.noplate = true;
-                }
-                if (!stand.hasGravity()) {
-                    this.stand.nogravity = true;
+                    this.stand.noPlate = true;
                 }
                 if (!stand.isVisible()) {
                     this.stand.invisible = true;
@@ -274,10 +272,19 @@ public class EntityWrapper {
                     this.stand.small = true;
                 }
                 return;
-            }
-            case ENDERMITE: // NEW
+            case ENDERMITE:
+                return;
             case BAT:
+                if (((Bat) entity).isAwake()) {
+                    this.dataByte = (byte) 1;
+                } else {
+                    this.dataByte = (byte) 0;
+                }
+                return;
             case ENDER_DRAGON:
+                EnderDragon entity1 = (EnderDragon) entity;
+                this.dataByte = (byte) entity1.getPhase().ordinal();
+                return;
             case GHAST:
             case MAGMA_CUBE:
             case SQUID:
@@ -292,62 +299,77 @@ public class EntityWrapper {
             case ENDERMAN:
             case CREEPER:
             case BLAZE:
+            case SHULKER:
             case SNOWMAN:
-            case IRON_GOLEM: {
                 storeLiving((LivingEntity) entity);
                 return;
-            }
-            // END LIVING //
+            case IRON_GOLEM:
+                if (((IronGolem) entity).isPlayerCreated()) {
+                    this.dataByte = (byte) 1;
+                } else {
+                    this.dataByte = (byte) 0;
+                }
+                storeLiving((LivingEntity) entity);
+                // END LIVING //
         }
     }
 
     @Override
-    public boolean equals(final Object obj) {
-        return hash == obj.hashCode();
+    public boolean equals(Object obj) {
+        return this.hash == obj.hashCode();
     }
 
     @Override
     public int hashCode() {
-        return hash;
+        return this.hash;
     }
 
-    public void storeInventory(final InventoryHolder held) {
-        inventory = held.getInventory().getContents().clone();
+    public void storeInventory(InventoryHolder held) {
+        this.inventory = held.getInventory().getContents().clone();
     }
 
-    private void restoreLiving(final LivingEntity entity) {
-        entity.setCanPickupItems(lived.loot);
-        if (lived.name != null) {
-            entity.setCustomName(lived.name);
-            entity.setCustomNameVisible(lived.visible);
+    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 ((lived.potions != null) && (!lived.potions.isEmpty())) {
-            entity.addPotionEffects(lived.potions);
+        if (this.lived.potions != null && !this.lived.potions.isEmpty()) {
+            entity.addPotionEffects(this.lived.potions);
         }
-        entity.setRemainingAir(lived.air);
-        entity.setRemoveWhenFarAway(lived.persistent);
-        if (lived.equipped) {
-            final EntityEquipment equipment = entity.getEquipment();
-            equipment.setItemInHand(lived.hands);
-            equipment.setHelmet(lived.helmet);
-            equipment.setChestplate(lived.chestplate);
-            equipment.setLeggings(lived.leggings);
-            equipment.setBoots(lived.boots);
+        entity.setRemainingAir(this.lived.air);
+        entity.setRemoveWhenFarAway(this.lived.persistent);
+        if (this.lived.equipped) {
+            this.restoreEquipment(entity);
         }
-        if (lived.leashed) {
+        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 leash = world.spawnEntity(new Location(world, Math.floor(x) + lived.leashX, Math.floor(y) + lived.leashY, Math
+            // .floor(z) + lived.leashZ), EntityType.LEASH_HITCH);
             //            entity.setLeashHolder(leash);
         }
     }
 
-    private void restoreInventory(final InventoryHolder entity) {
-        entity.getInventory().setContents(inventory);
+    void restoreEquipment(LivingEntity entity) {
+        EntityEquipment equipment = entity.getEquipment();
+        if (PS.get().checkVersion(PS.get().IMP.getServerVersion(), 1, 9, 0)) {
+            equipment.setItemInMainHand(this.lived.mainHand);
+            equipment.setItemInOffHand(this.lived.offHand);
+        } else {
+            equipment.setItemInHand(this.lived.mainHand);
+        }
+        equipment.setHelmet(this.lived.helmet);
+        equipment.setChestplate(this.lived.chestplate);
+        equipment.setLeggings(this.lived.leggings);
+        equipment.setBoots(this.lived.boots);
     }
 
-    public void storeLiving(final LivingEntity lived) {
+    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();
@@ -358,112 +380,128 @@ public class EntityWrapper {
         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) (x - loc.getBlockX());
-            this.lived.leash_y = (short) (y - loc.getBlockY());
-            this.lived.leash_z = (short) (z - loc.getBlockZ());
+            Location location = lived.getLeashHolder().getLocation();
+            this.lived.leashX = (short) (this.x - location.getBlockX());
+            this.lived.leashY = (short) (this.y - location.getBlockY());
+            this.lived.leashZ = (short) (this.z - location.getBlockZ());
         }
-        final EntityEquipment equipment = lived.getEquipment();
+        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();
+            storeEquipment(equipment);
         }
     }
 
-    private void restoreTameable(final Tameable entity) {
-        if (tamed.tamed) {
-            if (tamed.owner != null) {
+    void storeEquipment(EntityEquipment equipment) {
+        if (PS.get().checkVersion(PS.get().IMP.getServerVersion(), 1, 9, 0)) {
+            this.lived.mainHand = equipment.getItemInMainHand().clone();
+            this.lived.offHand = equipment.getItemInOffHand().clone();
+        } else {
+            this.lived.mainHand = equipment.getItemInHand().clone();
+            this.lived.offHand = null;
+        }
+        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(tamed.owner);
+                entity.setOwner(this.tamed.owner);
             }
         }
     }
 
-    private void restoreAgeable(final Ageable entity) {
-        if (!aged.adult) {
+    private void restoreAgeable(Ageable entity) {
+        if (!this.aged.adult) {
             entity.setBaby();
         }
-        entity.setAgeLock(aged.locked);
-        if (aged.age > 0) {
-            entity.setAge(aged.age);
+        entity.setAgeLock(this.aged.locked);
+        if (this.aged.age > 0) {
+            entity.setAge(this.aged.age);
         }
     }
 
-    public void storeAgeable(final Ageable aged) {
+    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(final Tameable tamed) {
+    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, x + x_offset, y, z + z_offset);
-        loc.setYaw(yaw);
-        loc.setPitch(pitch);
-        if (type.isSpawnable()) {
+    public Entity spawn(World world, int xOffset, int zOffset) {
+        Location location = new Location(world, this.x + xOffset, this.y, this.z + zOffset);
+        location.setYaw(this.yaw);
+        location.setPitch(this.pitch);
+        if (!this.type.isSpawnable()) {
             return null;
         }
         Entity entity;
-        switch (type) {
-            case DROPPED_ITEM: {
-                return world.dropItem(loc, stack);
-            }
+        switch (this.type) {
+            case DROPPED_ITEM:
+                return world.dropItem(location, this.stack);
             case PLAYER:
-            case LEASH_HITCH: {
+            case LEASH_HITCH:
                 return null;
-            }
-            case ITEM_FRAME: {
-                entity = world.spawn(loc, ItemFrame.class);
+            case ITEM_FRAME:
+                entity = world.spawn(location, ItemFrame.class);
                 break;
-            }
-            case PAINTING: {
-                entity = world.spawn(loc, Painting.class);
+            case PAINTING:
+                entity = world.spawn(location, Painting.class);
                 break;
-            }
             default:
-                entity = world.spawnEntity(loc, type);
+                entity = world.spawnEntity(location, this.type);
                 break;
         }
-        if (depth == 0) {
+        if (this.depth == 0) {
             return entity;
         }
-        if (base.passenger != null) {
+        if (this.base.passenger != null) {
             try {
-                entity.setPassenger(base.passenger.spawn(world, x_offset, z_offset));
-            } catch (final Exception e) {}
+                entity.setPassenger(this.base.passenger.spawn(world, xOffset, zOffset));
+            } catch (Exception ignored) { }
         }
-        if (base.fall != 0) {
-            entity.setFallDistance(base.fall);
+        if (this.base.fall != 0) {
+            entity.setFallDistance(this.base.fall);
         }
-        if (base.fire != 0) {
-            entity.setFireTicks(base.fire);
+        if (this.base.fire != 0) {
+            entity.setFireTicks(this.base.fire);
         }
-        if (base.age != 0) {
-            entity.setTicksLived(base.age);
+        if (this.base.age != 0) {
+            entity.setTicksLived(this.base.age);
         }
-        entity.setVelocity(new Vector(base.v_x, base.v_y, base.v_z));
-        if (depth == 1) {
+        entity.setVelocity(new Vector(this.base.vX, this.base.vY, this.base.vZ));
+        if (this.depth == 1) {
             return entity;
         }
+        if (PS.get().checkVersion(PS.get().IMP.getServerVersion(), 1, 10, 0) || entity instanceof ArmorStand) {
+            if (this.noGravity) {
+                entity.setGravity(false);
+            }
+        }
         switch (entity.getType()) {
             case ARROW:
             case BOAT:
+                if (PS.get().checkVersion(PS.get().IMP.getServerVersion(), 1, 9, 0)) {
+                    Boat boat = (Boat) entity;
+                    boat.setWoodType(TreeSpecies.values()[dataByte]);
+                }
+
             case COMPLEX_PART:
             case EGG:
             case ENDER_CRYSTAL:
             case ENDER_PEARL:
             case ENDER_SIGNAL:
+            case DROPPED_ITEM:
             case EXPERIENCE_ORB:
             case FALLING_BLOCK:
             case FIREBALL:
@@ -477,154 +515,149 @@ public class EntityWrapper {
             case MINECART_TNT:
             case PLAYER:
             case PRIMED_TNT:
+                return entity;
             case SLIME:
+                ((Slime) entity).setSize(this.dataByte);
+                return entity;
             case SMALL_FIREBALL:
             case SNOWBALL:
             case SPLASH_POTION:
             case THROWN_EXP_BOTTLE:
             case WEATHER:
+            case TIPPED_ARROW:
+            case SPECTRAL_ARROW:
+            case SHULKER_BULLET:
+            case LINGERING_POTION:
+            case AREA_EFFECT_CLOUD:
+            case DRAGON_FIREBALL:
             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;
-                itemframe.setRotation(Rotation.values()[dataByte]);
-                itemframe.setItem(stack);
+            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;
-                painting.setFacingDirection(BlockFace.values()[dataByte], true);
-                painting.setArt(Art.getByName(dataString), true);
+            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]);
-                horse.setStyle(Style.values()[this.horse.style]);
-                horse.setColor(Color.values()[this.horse.color]);
-                restoreTameable((Tameable) entity);
-                restoreAgeable((Ageable) entity);
-                restoreLiving((LivingEntity) entity);
-                restoreInventory((InventoryHolder) entity);
+                horse.setVariant(this.horse.variant);
+                horse.setStyle(this.horse.style);
+                horse.setColor(this.horse.color);
+                restoreTameable(horse);
+                restoreAgeable(horse);
+                restoreLiving(horse);
+                restoreInventory(horse);
                 return entity;
-            }
             // END INVENTORY HOLDER //
             case WOLF:
-            case OCELOT: {
+            case OCELOT:
                 restoreTameable((Tameable) entity);
                 restoreAgeable((Ageable) entity);
                 restoreLiving((LivingEntity) entity);
                 return entity;
-            }
             // END AGEABLE //
-            case SHEEP: {
-                final Sheep sheep = (Sheep) entity;
-                if (dataByte == 1) {
+            case SHEEP:
+                Sheep sheep = (Sheep) entity;
+                if (this.dataByte == 1) {
                     sheep.setSheared(true);
                 }
-                if (dataByte2 != 0) {
-                    sheep.setColor(DyeColor.getByDyeData(dataByte2));
+                if (this.dataByte2 != 0) {
+                    sheep.setColor(DyeColor.getByDyeData(this.dataByte2));
                 }
-                restoreAgeable((Ageable) entity);
-                restoreLiving((LivingEntity) entity);
-                return entity;
-            }
+                restoreAgeable(sheep);
+                restoreLiving(sheep);
+                return sheep;
             case VILLAGER:
             case CHICKEN:
             case COW:
+            case POLAR_BEAR:
             case MUSHROOM_COW:
-            case PIG: {
+            case PIG:
                 restoreAgeable((Ageable) entity);
                 restoreLiving((LivingEntity) entity);
                 return entity;
-            }
             // END AGEABLE //
-            case RABBIT: { // NEW
-                if (dataByte != 0) {
-                    ((Rabbit) entity).setRabbitType(Type.values()[dataByte]);
+            case RABBIT:
+                if (this.dataByte != 0) {
+                    ((Rabbit) entity).setRabbitType(Type.values()[this.dataByte]);
                 }
                 restoreAgeable((Ageable) entity);
                 restoreLiving((LivingEntity) entity);
                 return entity;
-            }
-            case GUARDIAN: { // NEW
-                if (dataByte != 0) {
+            case GUARDIAN:
+                if (this.dataByte != 0) {
                     ((Guardian) entity).setElder(true);
                 }
                 restoreLiving((LivingEntity) entity);
                 return entity;
-            }
-            case SKELETON: { // NEW
-                if (dataByte != 0) {
-                    ((Skeleton) entity).setSkeletonType(SkeletonType.values()[dataByte]);
+            case SKELETON:
+                if (this.dataByte != 0) {
+                    ((Skeleton) entity).setSkeletonType(SkeletonType.values()[this.dataByte]);
                 }
                 storeLiving((LivingEntity) entity);
                 return entity;
-            }
-            case ARMOR_STAND: { // NEW
-                                // CHECK positions
-                final ArmorStand stand = (ArmorStand) entity;
-                if (inventory[0] != null) {
-                    stand.setItemInHand(inventory[0]);
+            case ARMOR_STAND:
+                // CHECK positions
+                ArmorStand stand = (ArmorStand) entity;
+                if (this.inventory[0] != null) {
+                    stand.setItemInHand(this.inventory[0]);
                 }
-                if (inventory[1] != null) {
-                    stand.setHelmet(inventory[1]);
+                if (this.inventory[1] != null) {
+                    stand.setHelmet(this.inventory[1]);
                 }
-                if (inventory[2] != null) {
-                    stand.setChestplate(inventory[2]);
+                if (this.inventory[2] != null) {
+                    stand.setChestplate(this.inventory[2]);
                 }
-                if (inventory[3] != null) {
-                    stand.setLeggings(inventory[3]);
+                if (this.inventory[3] != null) {
+                    stand.setLeggings(this.inventory[3]);
                 }
-                if (inventory[4] != null) {
-                    stand.setBoots(inventory[4]);
+                if (this.inventory[4] != null) {
+                    stand.setBoots(this.inventory[4]);
                 }
-                if ((this.stand.head[0] != 0) || (this.stand.head[1] != 0) || (this.stand.head[2] != 0)) {
-                    final EulerAngle pose = new EulerAngle(this.stand.head[0], this.stand.head[1], this.stand.head[2]);
+                if (this.stand.head[0] != 0 || this.stand.head[1] != 0 || this.stand.head[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.head[0], this.stand.head[1], this.stand.head[2]);
                     stand.setHeadPose(pose);
                 }
-                if ((this.stand.body[0] != 0) || (this.stand.body[1] != 0) || (this.stand.body[2] != 0)) {
-                    final EulerAngle pose = new EulerAngle(this.stand.body[0], this.stand.body[1], this.stand.body[2]);
+                if (this.stand.body[0] != 0 || this.stand.body[1] != 0 || this.stand.body[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.body[0], this.stand.body[1], this.stand.body[2]);
                     stand.setBodyPose(pose);
                 }
-                if ((this.stand.leftLeg[0] != 0) || (this.stand.leftLeg[1] != 0) || (this.stand.leftLeg[2] != 0)) {
-                    final EulerAngle pose = new EulerAngle(this.stand.leftLeg[0], this.stand.leftLeg[1], this.stand.leftLeg[2]);
+                if (this.stand.leftLeg[0] != 0 || this.stand.leftLeg[1] != 0 || this.stand.leftLeg[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.leftLeg[0], this.stand.leftLeg[1], this.stand.leftLeg[2]);
                     stand.setLeftLegPose(pose);
                 }
-                if ((this.stand.rightLeg[0] != 0) || (this.stand.rightLeg[1] != 0) || (this.stand.rightLeg[2] != 0)) {
-                    final EulerAngle pose = new EulerAngle(this.stand.rightLeg[0], this.stand.rightLeg[1], this.stand.rightLeg[2]);
+                if (this.stand.rightLeg[0] != 0 || this.stand.rightLeg[1] != 0 || this.stand.rightLeg[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.rightLeg[0], this.stand.rightLeg[1], this.stand.rightLeg[2]);
                     stand.setRightLegPose(pose);
                 }
-                if ((this.stand.leftArm[0] != 0) || (this.stand.leftArm[1] != 0) || (this.stand.leftArm[2] != 0)) {
-                    final EulerAngle pose = new EulerAngle(this.stand.leftArm[0], this.stand.leftArm[1], this.stand.leftArm[2]);
+                if (this.stand.leftArm[0] != 0 || this.stand.leftArm[1] != 0 || this.stand.leftArm[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.leftArm[0], this.stand.leftArm[1], this.stand.leftArm[2]);
                     stand.setLeftArmPose(pose);
                 }
-                if ((this.stand.rightArm[0] != 0) || (this.stand.rightArm[1] != 0) || (this.stand.rightArm[2] != 0)) {
-                    final EulerAngle pose = new EulerAngle(this.stand.rightArm[0], this.stand.rightArm[1], this.stand.rightArm[2]);
+                if (this.stand.rightArm[0] != 0 || this.stand.rightArm[1] != 0 || this.stand.rightArm[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.rightArm[0], this.stand.rightArm[1], this.stand.rightArm[2]);
                     stand.setRightArmPose(pose);
                 }
                 if (this.stand.invisible) {
@@ -633,21 +666,27 @@ public class EntityWrapper {
                 if (this.stand.arms) {
                     stand.setArms(true);
                 }
-                if (this.stand.nogravity) {
-                    stand.setGravity(false);
-                }
-                if (this.stand.noplate) {
+                if (this.stand.noPlate) {
                     stand.setBasePlate(false);
                 }
                 if (this.stand.small) {
                     stand.setSmall(true);
                 }
+                restoreLiving(stand);
+                return stand;
+            case BAT:
+                if (this.dataByte != 0) {
+                    ((Bat) entity).setAwake(true);
+                }
                 restoreLiving((LivingEntity) entity);
                 return entity;
-            }
-            case ENDERMITE: // NEW
-            case BAT:
             case ENDER_DRAGON:
+                if (this.dataByte != 0) {
+                    ((EnderDragon) entity).setPhase(EnderDragon.Phase.values()[this.dataByte]);
+                }
+                restoreLiving((LivingEntity) entity);
+                return entity;
+            case ENDERMITE:
             case GHAST:
             case MAGMA_CUBE:
             case SQUID:
@@ -663,15 +702,20 @@ public class EntityWrapper {
             case CREEPER:
             case BLAZE:
             case SNOWMAN:
-            case IRON_GOLEM: {
+            case SHULKER:
                 restoreLiving((LivingEntity) entity);
                 return entity;
-            }
-            // END LIVING //
+            case IRON_GOLEM:
+                if (this.dataByte != 0) {
+                    ((IronGolem) entity).setPlayerCreated(true);
+                }
+                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;
@@ -679,4 +723,10 @@ public class EntityWrapper {
         }
         return 0;
     }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public String toString() {
+        return String.format("[%s, x=%s, y=%s, z=%s]", type.getName(), x, y, z);
+    }
 }

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

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

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

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

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

@@ -2,7 +2,8 @@ package com.plotsquared.bukkit.object.entity;
 
 import org.bukkit.entity.AnimalTamer;
 
-public class TameableStats {
-    public AnimalTamer owner;
-    public boolean tamed;
+class TameableStats {
+
+    AnimalTamer owner;
+    boolean tamed;
 }

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

@@ -1,90 +1,109 @@
 package com.plotsquared.bukkit.object.schematic;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-
-import org.bukkit.block.BlockState;
-import org.bukkit.enchantments.Enchantment;
-import org.bukkit.inventory.InventoryHolder;
-import org.bukkit.inventory.ItemStack;
-
 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.object.schematic.PlotItem;
 import com.intellectualcrafters.plot.util.MathMan;
-import com.intellectualcrafters.plot.util.SchematicHandler.Schematic;
+import com.plotsquared.bukkit.util.BukkitUtil;
+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;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
 
 public class StateWrapper {
-    
+
     public BlockState state = null;
     public CompoundTag tag = null;
-    
-    public StateWrapper(final BlockState state) {
+
+    public StateWrapper(BlockState state) {
         this.state = state;
     }
-    
-    public StateWrapper(final CompoundTag tag) {
+
+    public StateWrapper(CompoundTag tag) {
         this.tag = tag;
     }
-    
-    public boolean restoreTag(final short x, final short y, final short z, final Schematic schematic) {
-        if (tag == null) {
+
+    public boolean restoreTag(String worldName, int x, int y, int z) {
+        if (this.tag == null) {
             return false;
         }
-        final List<Tag> itemsTag = tag.getListTag("Items").getValue();
-        final int length = itemsTag.size();
-        final short[] ids = new short[length];
-        final byte[] datas = new byte[length];
-        final byte[] amounts = new byte[length];
-        for (int i = 0; i < length; i++) {
-            final Tag itemTag = itemsTag.get(i);
-            final CompoundTag itemComp = (CompoundTag) itemTag;
-            short id = itemComp.getShort("id");
-            String idStr = itemComp.getString("id");
-            if (idStr != null && !MathMan.isInteger(idStr)) {
-                idStr = idStr.split(":")[0].toLowerCase();
-                id = (short) ItemType.getId(idStr);
-            }
-            ids[i] = id;
-            datas[i] = (byte) itemComp.getShort("Damage");
-            amounts[i] = itemComp.getByte("Count");
+        switch (this.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;
+                }
         }
-        if (length != 0) {
-            schematic.addItem(new PlotItem(x, y, z, ids, datas, amounts));
-        }
-        return true;
+        return false;
     }
-    
+
     public CompoundTag getTag() {
-        if (tag != null) {
-            return tag;
+        if (this.tag != null) {
+            return this.tag;
         }
-        if (state instanceof InventoryHolder) {
-            final InventoryHolder inv = (InventoryHolder) state;
-            final ItemStack[] contents = inv.getInventory().getContents();
-            final Map<String, Tag> values = new HashMap<>();
+        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(final ItemStack[] items) {
-        final List<CompoundTag> tags = new ArrayList<>();
+
+    public List<CompoundTag> serializeInventory(ItemStack[] items) {
+        List<CompoundTag> tags = new ArrayList<>();
         for (int i = 0; i < items.length; ++i) {
             if (items[i] != null) {
-                final Map<String, Tag> tagData = serializeItem(items[i]);
+                Map<String, Tag> tagData = serializeItem(items[i]);
                 tagData.put("Slot", new ByteTag("Slot", (byte) i));
                 tags.add(new CompoundTag(tagData));
             }
@@ -103,21 +122,21 @@ public class StateWrapper {
         return data;
     }
     */
-    
-    public Map<String, Tag> serializeItem(final ItemStack item) {
-        final Map<String, Tag> data = new HashMap<>();
+
+    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()) {
-            final List<CompoundTag> enchantmentList = new ArrayList<>();
-            for (final Entry<Enchantment, Integer> entry : item.getEnchantments().entrySet()) {
-                final Map<String, Tag> enchantment = new HashMap<>();
+            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));
             }
-            final Map<String, Tag> auxData = new HashMap<>();
+            Map<String, Tag> auxData = new HashMap<>();
             auxData.put("ench", new ListTag("ench", CompoundTag.class, enchantmentList));
             data.put("tag", new CompoundTag("tag", auxData));
         }

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

@@ -4,17 +4,14 @@ import com.intellectualcrafters.plot.object.PlotPlayer;
 import com.intellectualcrafters.plot.util.AbstractTitle;
 import com.plotsquared.bukkit.object.BukkitPlayer;
 
-import java.lang.reflect.InvocationTargetException;
-
 public class DefaultTitle extends AbstractTitle {
 
     @Override
-    public void sendTitle(final PlotPlayer player, final String head, final String sub, final int in, final int delay, final 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 (ClassNotFoundException | InvocationTargetException | SecurityException | NoSuchMethodException | InstantiationException |
-                IllegalArgumentException | IllegalAccessException e) {
+        } catch (Exception ignored) {
             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

@@ -1,399 +1,113 @@
 package com.plotsquared.bukkit.titles;
 
-import org.bukkit.Bukkit;
+import com.plotsquared.bukkit.chat.Reflection;
 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 ]
- *
- * @version 1.1.0
- * @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;
+public class DefaultTitleManager extends TitleManager {
 
     /**
-     * Create a new 1.8 title
+     * Create a new 1.8 title.
      *
-     * @param title
-     *            Title
-     * @throws ClassNotFoundException
+     * @param title Title text
+     * @param subtitle Subtitle text
+     * @param fadeInTime Fade in time
+     * @param stayTime Stay on screen time
+     * @param fadeOutTime Fade out time
      */
-    public DefaultTitleManager(final String title) throws ClassNotFoundException {
-        this.title = title;
-        loadClasses();
+    public DefaultTitleManager(String title, String subtitle, int fadeInTime, int stayTime, int fadeOutTime) {
+        super(title, subtitle, fadeInTime, stayTime, fadeOutTime);
     }
 
     /**
-     * Create a new 1.8 title
-     *
-     * @param title
-     *            Title text
-     * @param subtitle
-     *            Subtitle text
-     * @throws ClassNotFoundException
+     * Load spigot and NMS classes.
      */
-    public DefaultTitleManager(final String title, final String subtitle) throws ClassNotFoundException {
-        this.title = title;
-        this.subtitle = subtitle;
-        loadClasses();
+    @Override void loadClasses() {
+        this.packetTitle = Reflection.getNMSClass("PacketPlayOutTitle");
+        this.packetActions = Reflection.getNMSClass("EnumTitleAction");
+        this.chatBaseComponent = Reflection.getNMSClass("IChatBaseComponent");
+        this.nmsChatSerializer = Reflection.getNMSClass("ChatSerializer");
     }
 
-    /**
-     * Copy 1.8 title
-     *
-     * @param title
-     *            Title
-     * @throws ClassNotFoundException
-     */
-    public DefaultTitleManager(final DefaultTitleManager title) throws ClassNotFoundException {
-        // Copy title
-        this.title = title.title;
-        subtitle = title.subtitle;
-        titleColor = title.titleColor;
-        subtitleColor = title.subtitleColor;
-        fadeInTime = title.fadeInTime;
-        fadeOutTime = title.fadeOutTime;
-        stayTime = title.stayTime;
-        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(final String title, final String subtitle, final int fadeInTime, final int stayTime, final int fadeOutTime)
-            throws ClassNotFoundException {
-        this.title = title;
-        this.subtitle = subtitle;
-        this.fadeInTime = fadeInTime;
-        this.stayTime = stayTime;
-        this.fadeOutTime = fadeOutTime;
-        loadClasses();
-    }
-
-    private static boolean equalsTypeArray(final Class<?>[] a, final 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
-     * @throws ClassNotFoundException
-     */
-    private void loadClasses() throws ClassNotFoundException {
-        packetTitle = getNMSClass("PacketPlayOutTitle");
-        packetActions = getNMSClass("EnumTitleAction");
-        chatBaseComponent = getNMSClass("IChatBaseComponent");
-        nmsChatSerializer = getNMSClass("ChatSerializer");
-    }
-
-    /**
-     * Get title text
-     *
-     * @return Title text
-     */
-    public String getTitle() {
-        return title;
-    }
-
-    /**
-     * Set title text
-     *
-     * @param title
-     *            Title
-     */
-    public void setTitle(final String title) {
-        this.title = title;
-    }
-
-    /**
-     * Get subtitle text
-     *
-     * @return Subtitle text
-     */
-    public String getSubtitle() {
-        return subtitle;
-    }
-
-    /**
-     * Set subtitle text
-     *
-     * @param subtitle
-     *            Subtitle text
-     */
-    public void setSubtitle(final String subtitle) {
-        this.subtitle = subtitle;
-    }
-
-    /**
-     * Set the title color
-     *
-     * @param color
-     *            Chat color
-     */
-    public void setTitleColor(final ChatColor color) {
-        titleColor = color;
-    }
-
-    /**
-     * Set the subtitle color
-     *
-     * @param color
-     *            Chat color
-     */
-    public void setSubtitleColor(final ChatColor color) {
-        subtitleColor = color;
-    }
-
-    /**
-     * Set title fade in time
-     *
-     * @param time
-     *            Time
-     */
-    public void setFadeInTime(final int time) {
-        fadeInTime = time;
-    }
-
-    /**
-     * Set title fade out time
-     *
-     * @param time
-     *            Time
-     */
-    public void setFadeOutTime(final int time) {
-        fadeOutTime = time;
-    }
-
-    /**
-     * Set title stay time
-     *
-     * @param time
-     *            Time
-     */
-    public void setStayTime(final int time) {
-        stayTime = time;
-    }
-
-    /**
-     * Set timings to ticks
-     */
-    public void setTimingsToTicks() {
-        ticks = true;
-    }
-
-    /**
-     * Set timings to seconds
-     */
-    public void setTimingsToSeconds() {
-        ticks = false;
-    }
-
-    /**
-     * Send the title to a player
-     *
-     * @param player
-     *            Player
-     * @throws InvocationTargetException
-     * @throws IllegalArgumentException
-     * @throws IllegalAccessException
-     */
-    public void send(final Player player)
-            throws IllegalArgumentException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException,
-            SecurityException {
-        if (packetTitle != null) {
+    @Override public void send(Player player) throws IllegalArgumentException, ReflectiveOperationException, SecurityException {
+        if (this.packetTitle != null) {
             // First reset previous settings
             resetTitle(player);
             // Send timings first
-            final Object handle = getHandle(player);
-            final Object connection = getField(handle.getClass(), "playerConnection").get(handle);
-            final Object[] actions = packetActions.getEnumConstants();
-            final Method sendPacket = getMethod(connection.getClass(), "sendPacket");
-            Object packet = packetTitle.getConstructor(packetActions, chatBaseComponent, Integer.TYPE, Integer.TYPE, Integer.TYPE)
-                    .newInstance(actions[2], null, fadeInTime * (ticks ? 1 : 20),
-                            stayTime * (ticks ? 1 : 20), fadeOutTime * (ticks ? 1 : 20));
+            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 (fadeInTime != -1 && fadeOutTime != -1 && stayTime != -1) {
+            if (this.fadeInTime != -1 && this.fadeOutTime != -1 && this.stayTime != -1) {
                 sendPacket.invoke(connection, packet);
             }
             // Send title
-            Object serialized = getMethod(nmsChatSerializer, "a", String.class).invoke(null,
-                    "{text:\"" + ChatColor.translateAlternateColorCodes('&', title) + "\",color:" + titleColor.name().toLowerCase() + "}");
-            packet = packetTitle.getConstructor(packetActions, chatBaseComponent).newInstance(actions[0], serialized);
+            Object serialized = getMethod(this.nmsChatSerializer, "a", String.class).invoke(null,
+                    "{text:\"" + ChatColor.translateAlternateColorCodes('&', this.getTitle()) + "\",color:" + this.titleColor.name().toLowerCase()
+                            + '}');
+            packet = this.packetTitle.getConstructor(this.packetActions, this.chatBaseComponent).newInstance(actions[0], serialized);
             sendPacket.invoke(connection, packet);
-            if (!subtitle.isEmpty()) {
+            if (!this.getSubtitle().isEmpty()) {
                 // Send subtitle if present
-                serialized = getMethod(nmsChatSerializer, "a", String.class).invoke(null,
-                        "{text:\"" + ChatColor.translateAlternateColorCodes('&', subtitle) + "\",color:" + subtitleColor.name().toLowerCase() + "}");
-                packet = packetTitle.getConstructor(packetActions, chatBaseComponent).newInstance(actions[1], serialized);
+                serialized = getMethod(this.nmsChatSerializer, "a", String.class).invoke(null,
+                        "{text:\"" + ChatColor.translateAlternateColorCodes('&', this.getSubtitle()) + "\",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 IllegalArgumentException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException,
-    SecurityException
-     */
-    public void broadcast()
-            throws IllegalArgumentException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException,
-            SecurityException {
-        for (final Player p : Bukkit.getOnlinePlayers()) {
-            send(p);
-        }
-    }
-
-    /**
-     * Clear the title
-     *
-     * @param player
-     *            Player
-     * @throws IllegalAccessException
-     * @throws IllegalArgumentException
-     */
-    public void clearTitle(final Player player)
-            throws IllegalArgumentException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException,
-            SecurityException {
+    @Override
+    public void clearTitle(Player player) throws IllegalArgumentException, ReflectiveOperationException, SecurityException {
         // Send timings first
-        final Object handle = getHandle(player);
-        final Object connection = getField(handle.getClass(), "playerConnection").get(handle);
-        final Object[] actions = packetActions.getEnumConstants();
-        final Method sendPacket = getMethod(connection.getClass(), "sendPacket");
-        final Object packet = packetTitle.getConstructor(packetActions, chatBaseComponent).newInstance(actions[3], null);
+        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
+     * Reset the title settings.
      *
-     * @param player
-     *            Player
+     * @param player Player
+     * @throws SecurityException
+     * @throws ReflectiveOperationException
+     * @throws SecurityException
      */
-    public void resetTitle(final Player player)
-            throws IllegalArgumentException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException,
-            SecurityException {
+    @Override
+    public void resetTitle(Player player) throws IllegalArgumentException, ReflectiveOperationException, SecurityException {
         // Send timings first
-        final Object handle = getHandle(player);
-        final Object connection = getField(handle.getClass(), "playerConnection").get(handle);
-        final Object[] actions = packetActions.getEnumConstants();
-        final Method sendPacket = getMethod(connection.getClass(), "sendPacket");
-        final Object packet = packetTitle.getConstructor(packetActions, chatBaseComponent).newInstance(actions[4], null);
+        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(final Class<?> clazz) {
-        return CORRESPONDING_TYPES.containsKey(clazz) ? CORRESPONDING_TYPES.get(clazz) : clazz;
-    }
-
-    private Class<?>[] toPrimitiveTypeArray(final Class<?>[] classes) {
-        final int a = classes != null ? classes.length : 0;
-        final Class<?>[] types = new Class<?>[a];
-        for (int i = 0; i < a; i++) {
-            types[i] = getPrimitiveType(classes[i]);
-        }
-        return types;
-    }
-
-    private Object getHandle(final Object obj) {
+    Field getField(Class<?> clazz, String name) {
         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(final String name, final Class<?> clazz, final Class<?>... paramTypes) {
-        final Class<?>[] t = toPrimitiveTypeArray(paramTypes);
-        for (final Method m : clazz.getMethods()) {
-            final Class<?>[] types = toPrimitiveTypeArray(m.getParameterTypes());
-            if (m.getName().equals(name) && equalsTypeArray(types, t)) {
-                return m;
-            }
-        }
-        return null;
-    }
-
-    private String getVersion() {
-        final String name = Bukkit.getServer().getClass().getPackage().getName();
-        return name.substring(name.lastIndexOf('.') + 1) + ".";
-    }
-
-    private Class<?> getNMSClass(final String className) throws ClassNotFoundException {
-        final String fullName = "net.minecraft.server." + getVersion() + className;
-        return Class.forName(fullName);
-    }
-
-    private Field getField(final Class<?> clazz, final String name) {
-        try {
-            final Field field = clazz.getDeclaredField(name);
+            Field field = clazz.getDeclaredField(name);
             field.setAccessible(true);
             return field;
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-            return null;
-        } catch (SecurityException e) {
+        } catch (NoSuchFieldException | SecurityException e) {
             e.printStackTrace();
             return null;
         }
     }
 
-    private Method getMethod(final Class<?> clazz, final String name, final Class<?>... args) {
-        for (final Method m : clazz.getMethods()) {
+    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;
@@ -402,7 +116,7 @@ public class DefaultTitleManager {
         return null;
     }
 
-    private boolean ClassListEqual(final Class<?>[] l1, final Class<?>[] l2) {
+    boolean ClassListEqual(Class<?>[] l1, Class<?>[] l2) {
         if (l1.length != l2.length) {
             return false;
         }

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

@@ -1,386 +1,76 @@
 package com.plotsquared.bukkit.titles;
 
-import org.bukkit.Bukkit;
+import com.plotsquared.bukkit.chat.Reflection;
 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 ]
- *
- * @version 1.1.0
- * @author Maxim Van de Wynckel
- *
- */
-public class DefaultTitleManager_183 {
-    /* 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;
-    private static final Map<Class<?>, Class<?>> CORRESPONDING_TYPES = new HashMap<>();
-    
+public class DefaultTitleManager_183 extends DefaultTitleManager {
+
     /**
-     * Create a new 1.8 title
+     * Create a new 1.8 title.
      *
-     * @param title
-     *            Title
-     * @throws ClassNotFoundException
+     * @param title Title text
+     * @param subtitle Subtitle text
+     * @param fadeInTime Fade in time
+     * @param stayTime Stay on screen time
+     * @param fadeOutTime Fade out time
      */
-    public DefaultTitleManager_183(final String title) throws ClassNotFoundException {
-        this.title = title;
-        loadClasses();
+    public DefaultTitleManager_183(String title, String subtitle, int fadeInTime, int stayTime, int fadeOutTime) {
+        super(title, subtitle, fadeInTime, stayTime, fadeOutTime);
     }
-    
+
     /**
-     * Create a new 1.8 title
-     *
-     * @param title
-     *            Title text
-     * @param subtitle
-     *            Subtitle text
-     * @throws ClassNotFoundException
+     * Load spigot and NMS classes.
      */
-    public DefaultTitleManager_183(final String title, final String subtitle) throws ClassNotFoundException {
-        this.title = title;
-        this.subtitle = subtitle;
-        loadClasses();
+    @Override
+    void loadClasses() {
+        this.packetTitle = Reflection.getNMSClass("PacketPlayOutTitle");
+        this.chatBaseComponent = Reflection.getNMSClass("IChatBaseComponent");
+        this.packetActions = Reflection.getNMSClass("PacketPlayOutTitle$EnumTitleAction");
+        this.nmsChatSerializer = Reflection.getNMSClass("IChatBaseComponent$ChatSerializer");
+
     }
-    
-    /**
-     * Copy 1.8 title
-     *
-     * @param title
-     *            Title
-     * @throws ClassNotFoundException
-     */
-    public DefaultTitleManager_183(final DefaultTitleManager_183 title) throws ClassNotFoundException {
-        // Copy title
-        this.title = title.title;
-        subtitle = title.subtitle;
-        titleColor = title.titleColor;
-        subtitleColor = title.subtitleColor;
-        fadeInTime = title.fadeInTime;
-        fadeOutTime = title.fadeOutTime;
-        stayTime = title.stayTime;
-        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(final String title, final String subtitle, final int fadeInTime, final int stayTime, final int fadeOutTime) throws ClassNotFoundException {
-        this.title = title;
-        this.subtitle = subtitle;
-        this.fadeInTime = fadeInTime;
-        this.stayTime = stayTime;
-        this.fadeOutTime = fadeOutTime;
-        loadClasses();
-    }
-    
-    /**
-     * Load spigot and NMS classes
-     * @throws ClassNotFoundException
-     */
-    private void loadClasses() throws ClassNotFoundException {
-        packetTitle = getNMSClass("PacketPlayOutTitle");
-        chatBaseComponent = getNMSClass("IChatBaseComponent");
-        packetActions = getNMSClass("PacketPlayOutTitle$EnumTitleAction");
-        nmsChatSerializer = getNMSClass("IChatBaseComponent$ChatSerializer");
-        
-    }
-    
-    /**
-     * Set title text
-     *
-     * @param title
-     *            Title
-     */
-    public void setTitle(final String title) {
-        this.title = title;
-    }
-    
-    /**
-     * Get title text
-     *
-     * @return Title text
-     */
-    public String getTitle() {
-        return title;
-    }
-    
-    /**
-     * Set subtitle text
-     *
-     * @param subtitle
-     *            Subtitle text
-     */
-    public void setSubtitle(final String subtitle) {
-        this.subtitle = subtitle;
-    }
-    
-    /**
-     * Get subtitle text
-     *
-     * @return Subtitle text
-     */
-    public String getSubtitle() {
-        return subtitle;
-    }
-    
-    /**
-     * Set the title color
-     *
-     * @param color
-     *            Chat color
-     */
-    public void setTitleColor(final ChatColor color) {
-        titleColor = color;
-    }
-    
-    /**
-     * Set the subtitle color
-     *
-     * @param color
-     *            Chat color
-     */
-    public void setSubtitleColor(final ChatColor color) {
-        subtitleColor = color;
-    }
-    
-    /**
-     * Set title fade in time
-     *
-     * @param time
-     *            Time
-     */
-    public void setFadeInTime(final int time) {
-        fadeInTime = time;
-    }
-    
-    /**
-     * Set title fade out time
-     *
-     * @param time
-     *            Time
-     */
-    public void setFadeOutTime(final int time) {
-        fadeOutTime = time;
-    }
-    
-    /**
-     * Set title stay time
-     *
-     * @param time
-     *            Time
-     */
-    public void setStayTime(final int time) {
-        stayTime = time;
-    }
-    
-    /**
-     * Set timings to ticks
-     */
-    public void setTimingsToTicks() {
-        ticks = true;
-    }
-    
-    /**
-     * Set timings to seconds
-     */
-    public void setTimingsToSeconds() {
-        ticks = false;
-    }
-    
-    /**
-     * Send the title to a player
-     *
-     * @param player
-     *            Player
-     * @throws InvocationTargetException
-     * @throws IllegalArgumentException
-     * @throws IllegalAccessException
-     */
-    public void send(final Player player) throws Exception {
-        if (packetTitle != null) {
+
+    @Override
+    public void send(Player player) throws IllegalArgumentException, ReflectiveOperationException, SecurityException {
+        if (this.packetTitle != null) {
             // First reset previous settings
             resetTitle(player);
             // Send timings first
-            final Object handle = getHandle(player);
-            final Object connection = getField(handle.getClass(), "playerConnection").get(handle);
-            final Object[] actions = packetActions.getEnumConstants();
-            final Method sendPacket = getMethod(connection.getClass(), "sendPacket");
-            Object packet = packetTitle.getConstructor(packetActions, chatBaseComponent, Integer.TYPE, Integer.TYPE, Integer.TYPE).newInstance(actions[2], null, fadeInTime * (ticks ? 1 : 20),
-            stayTime * (ticks ? 1 : 20), fadeOutTime * (ticks ? 1 : 20));
+            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 ((fadeInTime != -1) && (fadeOutTime != -1) && (stayTime != -1)) {
+            if ((this.fadeInTime != -1) && (this.fadeOutTime != -1) && (this.stayTime != -1)) {
                 sendPacket.invoke(connection, packet);
             }
             // Send title
-            Object serialized = getMethod(nmsChatSerializer, "a", String.class).invoke(null,
-            "{text:\"" + ChatColor.translateAlternateColorCodes('&', title) + "\",color:" + titleColor.name().toLowerCase() + "}");
-            packet = packetTitle.getConstructor(packetActions, chatBaseComponent).newInstance(actions[0], serialized);
+            Object serialized = getMethod(this.nmsChatSerializer, "a", String.class).invoke(null,
+                    "{text:\"" + ChatColor.translateAlternateColorCodes('&', this.getTitle()) + "\",color:" + this.titleColor.name().toLowerCase()
+                            + "}");
+            packet = this.packetTitle.getConstructor(this.packetActions, this.chatBaseComponent).newInstance(actions[0], serialized);
             sendPacket.invoke(connection, packet);
-            if (!subtitle.isEmpty()) {
+            if (!this.getSubtitle().isEmpty()) {
                 // Send subtitle if present
-                serialized = getMethod(nmsChatSerializer, "a", String.class).invoke(null,
-                "{text:\"" + ChatColor.translateAlternateColorCodes('&', subtitle) + "\",color:" + subtitleColor.name().toLowerCase() + "}");
-                packet = packetTitle.getConstructor(packetActions, chatBaseComponent).newInstance(actions[1], serialized);
+                serialized = getMethod(this.nmsChatSerializer, "a", String.class).invoke(null,
+                        "{text:\"" + ChatColor.translateAlternateColorCodes('&', this.getSubtitle()) + "\",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 (final Player p : Bukkit.getOnlinePlayers()) {
-            send(p);
-        }
-    }
-    
-    /**
-     * Clear the title
-     *
-     * @param player
-     *            Player
-     * @throws IllegalAccessException
-     * @throws IllegalArgumentException
-     */
-    public void clearTitle(final Player player) throws Exception {
-        // Send timings first
-        final Object handle = getHandle(player);
-        final Object connection = getField(handle.getClass(), "playerConnection").get(handle);
-        final Object[] actions = packetActions.getEnumConstants();
-        final Method sendPacket = getMethod(connection.getClass(), "sendPacket");
-        final Object packet = packetTitle.getConstructor(packetActions, chatBaseComponent).newInstance(actions[3], null);
-        sendPacket.invoke(connection, packet);
-    }
-    
-    /**
-     * Reset the title settings
-     *
-     * @param player
-     *            Player
-     * @throws SecurityException
-     * @throws NoSuchMethodException
-     * @throws InvocationTargetException
-     * @throws IllegalArgumentException
-     * @throws IllegalAccessException
-     * @throws InstantiationException
-     */
-    public void resetTitle(final Player player) throws Exception {
-        // Send timings first
-        final Object handle = getHandle(player);
-        final Object connection = getField(handle.getClass(), "playerConnection").get(handle);
-        final Object[] actions = packetActions.getEnumConstants();
-        final Method sendPacket = getMethod(connection.getClass(), "sendPacket");
-        final Object packet = packetTitle.getConstructor(packetActions, chatBaseComponent).newInstance(actions[4], null);
-        sendPacket.invoke(connection, packet);
-    }
-    
-    private Class<?> getPrimitiveType(final Class<?> clazz) {
-        return CORRESPONDING_TYPES.containsKey(clazz) ? CORRESPONDING_TYPES.get(clazz) : clazz;
-    }
-    
-    private Class<?>[] toPrimitiveTypeArray(final Class<?>[] classes) {
-        final int a = classes != null ? classes.length : 0;
-        final Class<?>[] types = new Class<?>[a];
-        for (int i = 0; i < a; i++) {
-            types[i] = getPrimitiveType(classes[i]);
-        }
-        return types;
-    }
-    
-    private static boolean equalsTypeArray(final Class<?>[] a, final 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;
-    }
-    
-    private Object getHandle(final Object obj) {
-        try {
-            return getMethod("getHandle", obj.getClass()).invoke(obj);
-        } catch (final Exception e) {
-            e.printStackTrace();
-            return null;
-        }
-    }
-    
-    private Method getMethod(final String name, final Class<?> clazz, final Class<?>... paramTypes) {
-        final Class<?>[] t = toPrimitiveTypeArray(paramTypes);
-        for (final Method m : clazz.getMethods()) {
-            final Class<?>[] types = toPrimitiveTypeArray(m.getParameterTypes());
-            if (m.getName().equals(name) && equalsTypeArray(types, t)) {
-                return m;
-            }
-        }
-        return null;
-    }
-    
-    private String getVersion() {
-        final String name = Bukkit.getServer().getClass().getPackage().getName();
-        final String version = name.substring(name.lastIndexOf('.') + 1) + ".";
-        return version;
-    }
-    
-    private Class<?> getNMSClass(final String className) throws ClassNotFoundException {
-        final String fullName = "net.minecraft.server." + getVersion() + className;
-        return Class.forName(fullName);
-    }
-    
-    private Field getField(final Class<?> clazz, final String name) {
-        try {
-            final Field field = clazz.getDeclaredField(name);
-            field.setAccessible(true);
-            return field;
-        } catch (final Exception e) {
-            e.printStackTrace();
-            return null;
-        }
-    }
-    
-    private Method getMethod(final Class<?> clazz, final String name, final Class<?>... args) {
-        for (final Method m : clazz.getMethods()) {
+
+    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;
@@ -388,18 +78,5 @@ public class DefaultTitleManager_183 {
         }
         return null;
     }
-    
-    private boolean ClassListEqual(final Class<?>[] l1, final 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, final int in, final int delay, final 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 (Exception ignored) {
             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 ignored) {
+            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, final int in, final int delay, final 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 (Exception e) {
+        } catch (Exception ignored) {
             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

@@ -1,414 +1,149 @@
 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 {
-    /* 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;
-    private static final Map<Class<?>, Class<?>> CORRESPONDING_TYPES = new HashMap<>();
-    
+public class HackTitleManager extends TitleManager {
+
     /**
-     * Create a new 1.8 title
+     * Create a new 1.8 title.
      *
-     * @param title
-     *            Title
-     * @throws ClassNotFoundException
+     * @param title Title text
+     * @param subtitle Subtitle text
+     * @param fadeInTime Fade in time
+     * @param stayTime Stay on screen time
+     * @param fadeOutTime Fade out time
      */
-    public HackTitleManager(final String title) throws ClassNotFoundException {
-        this.title = title;
-        loadClasses();
+    public HackTitleManager(String title, String subtitle, int fadeInTime, int stayTime, int fadeOutTime) {
+        super(title, subtitle, fadeInTime, stayTime, fadeOutTime);
     }
-    
+
     /**
-     * Create a new 1.8 title
-     *
-     * @param title
-     *            Title text
-     * @param subtitle
-     *            Subtitle text
-     * @throws ClassNotFoundException
+     * Load spigot and NMS classes.
      */
-    public HackTitleManager(final String title, final String subtitle) throws ClassNotFoundException {
-        this.title = title;
-        this.subtitle = subtitle;
-        loadClasses();
+    @Override
+    void loadClasses() {
+        this.packetTitle = getClass("org.spigotmc.ProtocolInjector$PacketTitle");
+        this.packetActions = getClass("org.spigotmc.ProtocolInjector$PacketTitle$Action");
+        this.nmsChatSerializer = Reflection.getNMSClass("ChatSerializer");
     }
-    
-    /**
-     * Copy 1.8 title
-     *
-     * @param title
-     *            Title
-     * @throws ClassNotFoundException
-     */
-    public HackTitleManager(final HackTitleManager title) throws ClassNotFoundException {
-        // Copy title
-        this.title = title.title;
-        subtitle = title.subtitle;
-        titleColor = title.titleColor;
-        subtitleColor = title.subtitleColor;
-        fadeInTime = title.fadeInTime;
-        fadeOutTime = title.fadeOutTime;
-        stayTime = title.stayTime;
-        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 HackTitleManager(final String title, final String subtitle, final int fadeInTime, final int stayTime, final int fadeOutTime) throws ClassNotFoundException {
-        this.title = title;
-        this.subtitle = subtitle;
-        this.fadeInTime = fadeInTime;
-        this.stayTime = stayTime;
-        this.fadeOutTime = fadeOutTime;
-        loadClasses();
-    }
-    
-    /**
-     * Load spigot and NMS classes
-     * @throws ClassNotFoundException
-     */
-    private void loadClasses() throws ClassNotFoundException {
-        packetTitle = getClass("org.spigotmc.ProtocolInjector$PacketTitle");
-        packetActions = getClass("org.spigotmc.ProtocolInjector$PacketTitle$Action");
-        nmsChatSerializer = getNMSClass("ChatSerializer");
-    }
-    
-    /**
-     * Set title text
-     *
-     * @param title
-     *            Title
-     */
-    public void setTitle(final String title) {
-        this.title = title;
-    }
-    
-    /**
-     * Get title text
-     *
-     * @return Title text
-     */
-    public String getTitle() {
-        return title;
-    }
-    
-    /**
-     * Set subtitle text
-     *
-     * @param subtitle
-     *            Subtitle text
-     */
-    public void setSubtitle(final String subtitle) {
-        this.subtitle = subtitle;
-    }
-    
-    /**
-     * Get subtitle text
-     *
-     * @return Subtitle text
-     */
-    public String getSubtitle() {
-        return subtitle;
-    }
-    
-    /**
-     * Set the title color
-     *
-     * @param color
-     *            Chat color
-     */
-    public void setTitleColor(final ChatColor color) {
-        titleColor = color;
-    }
-    
-    /**
-     * Set the subtitle color
-     *
-     * @param color
-     *            Chat color
-     */
-    public void setSubtitleColor(final ChatColor color) {
-        subtitleColor = color;
-    }
-    
-    /**
-     * Set title fade in time
-     *
-     * @param time
-     *            Time
-     */
-    public void setFadeInTime(final int time) {
-        fadeInTime = time;
-    }
-    
-    /**
-     * Set title fade out time
-     *
-     * @param time
-     *            Time
-     */
-    public void setFadeOutTime(final int time) {
-        fadeOutTime = time;
-    }
-    
-    /**
-     * Set title stay time
-     *
-     * @param time
-     *            Time
-     */
-    public void setStayTime(final int time) {
-        stayTime = time;
-    }
-    
-    /**
-     * Set timings to ticks
-     */
-    public void setTimingsToTicks() {
-        ticks = true;
-    }
-    
-    /**
-     * Set timings to seconds
-     */
-    public void setTimingsToSeconds() {
-        ticks = false;
-    }
-    
-    /**
-     * Send the title to a player
-     *
-     * @param player
-     *            Player
-     */
-    public void send(final Player player) throws Exception {
-        if ((getProtocolVersion(player) >= 47) && isSpigot() && (packetTitle != null)) {
+
+    @Override public void send(Player player) throws IllegalArgumentException, ReflectiveOperationException, SecurityException {
+        if ((getProtocolVersion(player) >= 47) && isSpigot() && (this.packetTitle != null)) {
             // First reset previous settings
             resetTitle(player);
             // Send timings first
-            final Object handle = getHandle(player);
-            final Object connection = getField(handle.getClass(), "playerConnection").get(handle);
-            final Object[] actions = packetActions.getEnumConstants();
-            final Method sendPacket = getMethod(connection.getClass(), "sendPacket");
-            Object packet = packetTitle.getConstructor(packetActions, Integer.TYPE, Integer.TYPE, Integer.TYPE).newInstance(actions[2], fadeInTime * (ticks ? 1 : 20), stayTime * (ticks ? 1 : 20),
-            fadeOutTime * (ticks ? 1 : 20));
+            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 ((fadeInTime != -1) && (fadeOutTime != -1) && (stayTime != -1)) {
+            if ((this.fadeInTime != -1) && (this.fadeOutTime != -1) && (this.stayTime != -1)) {
                 sendPacket.invoke(connection, packet);
             }
             // Send title
-            Object serialized = getMethod(nmsChatSerializer, "a", String.class).invoke(null,
-            "{text:\"" + ChatColor.translateAlternateColorCodes('&', title) + "\",color:" + titleColor.name().toLowerCase() + "}");
-            packet = packetTitle.getConstructor(packetActions, getNMSClass("IChatBaseComponent")).newInstance(actions[0], serialized);
+            Object serialized = getMethod(this.nmsChatSerializer, "a", String.class).invoke(null,
+                    "{text:\"" + ChatColor.translateAlternateColorCodes('&', this.getTitle()) + "\",color:" + this.titleColor.name().toLowerCase()
+                            + "}");
+            packet = this.packetTitle.getConstructor(this.packetActions, Reflection.getNMSClass("IChatBaseComponent"))
+                    .newInstance(actions[0], serialized);
             sendPacket.invoke(connection, packet);
-            if (!subtitle.isEmpty()) {
+            if (!this.getSubtitle().isEmpty()) {
                 // Send subtitle if present
-                serialized = getMethod(nmsChatSerializer, "a", String.class).invoke(null,
-                "{text:\"" + ChatColor.translateAlternateColorCodes('&', subtitle) + "\",color:" + subtitleColor.name().toLowerCase() + "}");
-                packet = packetTitle.getConstructor(packetActions, getNMSClass("IChatBaseComponent")).newInstance(actions[1], serialized);
+                serialized = getMethod(this.nmsChatSerializer, "a", String.class).invoke(null,
+                        "{text:\"" + ChatColor.translateAlternateColorCodes('&', this.getSubtitle()) + "\",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
-     */
-    public void broadcast() throws Exception {
-        for (final Player p : Bukkit.getOnlinePlayers()) {
-            send(p);
-        }
-    }
-    
-    /**
-     * Clear the title
-     *
-     * @param player
-     *            Player
-     * @throws Exception
-     */
-    public void clearTitle(final Player player) throws Exception {
+
+    @Override public void clearTitle(Player player) throws IllegalArgumentException, ReflectiveOperationException, SecurityException {
         if ((getProtocolVersion(player) >= 47) && isSpigot()) {
             // Send timings first
-            final Object handle = getHandle(player);
-            final Object connection = getField(handle.getClass(), "playerConnection").get(handle);
-            final Object[] actions = packetActions.getEnumConstants();
-            final Method sendPacket = getMethod(connection.getClass(), "sendPacket");
-            final Object packet = packetTitle.getConstructor(packetActions).newInstance(actions[3]);
+            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
-     */
-    public void resetTitle(final Player player) throws Exception {
+
+    @Override public void resetTitle(Player player) throws IllegalArgumentException, ReflectiveOperationException, SecurityException {
         if ((getProtocolVersion(player) >= 47) && isSpigot()) {
             // Send timings first
-            final Object handle = getHandle(player);
-            final Object connection = getField(handle.getClass(), "playerConnection").get(handle);
-            final Object[] actions = packetActions.getEnumConstants();
-            final Method sendPacket = getMethod(connection.getClass(), "sendPacket");
-            final Object packet = packetTitle.getConstructor(packetActions).newInstance(actions[4]);
+            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
+     * Get the protocol version of the player.
      *
-     * @param player
-     *            Player
+     * @param player Player
      * @return Protocol version
-     * @throws Exception
+     * @throws IllegalArgumentException
+     * @throws ReflectiveOperationException
+     * @throws SecurityException
      */
-    private int getProtocolVersion(final Player player) throws Exception {
-        final Object handle = getHandle(player);
-        final Object connection = getField(handle.getClass(), "playerConnection").get(handle);
-        final Object networkManager = getValue("networkManager", connection);
+    private int getProtocolVersion(Player player) throws IllegalArgumentException, ReflectiveOperationException, SecurityException {
+        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
+     * Check if running spigot.
      *
      * @return Spigot
      */
     private boolean isSpigot() {
         return Bukkit.getVersion().contains("Spigot");
     }
-    
+
     /**
-     * Get class by url
+     * Get class by url.
      *
-     * @param namespace
-     *            Namespace url
+     * @param namespace Namespace url
      * @return Class
      */
-    private Class<?> getClass(final String namespace) {
+    private Class<?> getClass(String namespace) {
         try {
             return Class.forName(namespace);
-        } catch (ClassNotFoundException e) {
-        }
+        } catch (ClassNotFoundException ignored) {}
         return null;
     }
-    
-    private Field getField(final String name, final Class<?> clazz) throws Exception {
+
+    private Field getField(String name, Class<?> clazz) throws NoSuchFieldException, SecurityException {
         return clazz.getDeclaredField(name);
     }
-    
-    private Object getValue(final String name, final Object obj) throws Exception {
-        final Field f = getField(name, obj.getClass());
+
+    private Object getValue(String name, Object obj) throws ReflectiveOperationException, SecurityException, IllegalArgumentException {
+        Field f = getField(name, obj.getClass());
         f.setAccessible(true);
         return f.get(obj);
     }
-    
-    private Class<?> getPrimitiveType(final Class<?> clazz) {
-        return CORRESPONDING_TYPES.containsKey(clazz) ? CORRESPONDING_TYPES.get(clazz) : clazz;
-    }
-    
-    private Class<?>[] toPrimitiveTypeArray(final Class<?>[] classes) {
-        final int a = classes != null ? classes.length : 0;
-        final Class<?>[] types = new Class<?>[a];
-        for (int i = 0; i < a; i++) {
-            types[i] = getPrimitiveType(classes[i]);
-        }
-        return types;
-    }
-    
-    private static boolean equalsTypeArray(final Class<?>[] a, final 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;
-    }
-    
-    private Object getHandle(final Object obj) {
+
+    private Field getField(Class<?> clazz, String name) {
         try {
-            return getMethod("getHandle", obj.getClass()).invoke(obj);
-        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
-            e.printStackTrace();
-            return null;
-        }
-    }
-    
-    private Method getMethod(final String name, final Class<?> clazz, final Class<?>... paramTypes) {
-        final Class<?>[] t = toPrimitiveTypeArray(paramTypes);
-        for (final Method m : clazz.getMethods()) {
-            final Class<?>[] types = toPrimitiveTypeArray(m.getParameterTypes());
-            if (m.getName().equals(name) && equalsTypeArray(types, t)) {
-                return m;
-            }
-        }
-        return null;
-    }
-    
-    private String getVersion() {
-        final String name = Bukkit.getServer().getClass().getPackage().getName();
-        return name.substring(name.lastIndexOf('.') + 1) + ".";
-    }
-    
-    private Class<?> getNMSClass(final String className) throws ClassNotFoundException {
-        final String fullName = "net.minecraft.server." + getVersion() + className;
-        return Class.forName(fullName);
-    }
-    
-    private Field getField(final Class<?> clazz, final String name) {
-        try {
-            final Field field = clazz.getDeclaredField(name);
+            Field field = clazz.getDeclaredField(name);
             field.setAccessible(true);
             return field;
         } catch (SecurityException | NoSuchFieldException e) {
@@ -416,18 +151,18 @@ public class HackTitleManager {
             return null;
         }
     }
-    
-    private Method getMethod(final Class<?> clazz, final String name, final Class<?>... args) {
-        for (final Method m : clazz.getMethods()) {
-            if (m.getName().equals(name) && ((args.length == 0) || ClassListEqual(args, m.getParameterTypes()))) {
+
+    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(final Class<?>[] l1, final Class<?>[] l2) {
+
+    private boolean classListEqual(Class<?>[] l1, Class<?>[] l2) {
         if (l1.length != l2.length) {
             return false;
         }
@@ -440,4 +175,5 @@ public class HackTitleManager {
         }
         return equal;
     }
+
 }

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

@@ -0,0 +1,244 @@
+package com.plotsquared.bukkit.titles;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+public abstract class TitleManager {
+
+    private static final Map<Class<?>, Class<?>> CORRESPONDING_TYPES = new HashMap<>();
+    /* Title packet */
+    Class<?> packetTitle;
+    /* Title packet actions ENUM */
+    Class<?> packetActions;
+    /* Chat serializer */
+    Class<?> nmsChatSerializer;
+    Class<?> chatBaseComponent;
+    ChatColor titleColor = ChatColor.WHITE;
+    ChatColor subtitleColor = ChatColor.WHITE;
+    /* Title timings */
+    int fadeInTime = -1;
+    int stayTime = -1;
+    int fadeOutTime = -1;
+    boolean ticks = false;
+    /* Title text and color */
+    private String title = "";
+    /* Subtitle text and color */
+    private String subtitle = "";
+
+    /**
+     * 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
+     */
+    TitleManager(String title, String subtitle, int fadeInTime, int stayTime, int fadeOutTime) {
+        this.title = title;
+        this.subtitle = subtitle;
+        this.fadeInTime = fadeInTime;
+        this.stayTime = stayTime;
+        this.fadeOutTime = fadeOutTime;
+        loadClasses();
+    }
+
+    abstract void loadClasses();
+
+    /**
+     * Get title text.
+     *
+     * @return Title text
+     */
+    public final String getTitle() {
+        return this.title;
+    }
+
+    /**
+     * Set title text.
+     *
+     * @param title Title
+     */
+    public final void setTitle(String title) {
+        this.title = title;
+    }
+
+    /**
+     * Get subtitle text.
+     *
+     * @return Subtitle text
+     */
+    public final String getSubtitle() {
+        return this.subtitle;
+    }
+
+    /**
+     * Set subtitle text.
+     *
+     * @param subtitle Subtitle text
+     */
+    public final void setSubtitle(String subtitle) {
+        this.subtitle = subtitle;
+    }
+
+    /**
+     * Set the title color.
+     *
+     * @param color Chat color
+     */
+    public final void setTitleColor(ChatColor color) {
+        this.titleColor = color;
+    }
+
+    /**
+     * Set the subtitle color.
+     *
+     * @param color Chat color
+     */
+    public final void setSubtitleColor(ChatColor color) {
+        this.subtitleColor = color;
+    }
+
+    /**
+     * Set title fade in time.
+     *
+     * @param time Time
+     */
+    public final void setFadeInTime(int time) {
+        this.fadeInTime = time;
+    }
+
+    /**
+     * Set title fade out time.
+     *
+     * @param time Time
+     */
+    public final void setFadeOutTime(int time) {
+        this.fadeOutTime = time;
+    }
+
+    /**
+     * Set title stay time.
+     *
+     * @param time Time
+     */
+    public final void setStayTime(int time) {
+        this.stayTime = time;
+    }
+
+    /**
+     * Set timings to ticks.
+     */
+    public final void setTimingsToTicks() {
+        this.ticks = true;
+    }
+
+    /**
+     * Set timings to seconds.
+     */
+    public final void setTimingsToSeconds() {
+        this.ticks = false;
+    }
+
+    /**
+     * Send the title to a player.
+     *
+     * @param player Player
+     * @throws IllegalArgumentException
+     * @throws ReflectiveOperationException
+     * @throws SecurityException
+     */
+    public abstract void send(Player player) throws IllegalArgumentException, ReflectiveOperationException, SecurityException;
+
+    /**
+     * Broadcast the title to all players.
+     *
+     * @throws Exception
+     */
+    public final void broadcast() throws Exception {
+        for (Player p : Bukkit.getOnlinePlayers()) {
+            send(p);
+        }
+    }
+
+    /**
+     * Clear the title.
+     *
+     * @param player Player
+     * @throws IllegalArgumentException
+     * @throws ReflectiveOperationException
+     * @throws SecurityException
+     */
+    public abstract void clearTitle(Player player) throws IllegalArgumentException, ReflectiveOperationException, SecurityException;
+
+    /**
+     * Reset the title settings.
+     *
+     * @param player Player
+     * @throws IllegalArgumentException
+     * @throws ReflectiveOperationException
+     * @throws SecurityException
+     */
+    public abstract void resetTitle(Player player) throws  IllegalArgumentException, ReflectiveOperationException, SecurityException;
+
+    private Class<?> getPrimitiveType(Class<?> clazz) {
+        if (CORRESPONDING_TYPES.containsKey(clazz)) {
+            return CORRESPONDING_TYPES.get(clazz);
+        } else {
+            return clazz;
+        }
+    }
+
+    final Class<?>[] toPrimitiveTypeArray(Class<?>[] classes) {
+        int a;
+        if (classes != null) {
+            a = classes.length;
+        } else {
+            a = 0;
+        }
+        Class<?>[] types = new Class<?>[a];
+        for (int i = 0; i < a; i++) {
+            types[i] = getPrimitiveType(classes[i]);
+        }
+        return types;
+    }
+
+    final Object getHandle(Object obj) {
+        try {
+            return getMethod("getHandle", obj.getClass()).invoke(obj);
+        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    final 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;
+    }
+
+    final 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;
+    }
+
+}

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

@@ -1,6 +1,7 @@
 package com.plotsquared.bukkit.util;
 
 import com.intellectualcrafters.plot.config.C;
+import com.intellectualcrafters.plot.config.Settings;
 import com.intellectualcrafters.plot.object.ConsolePlayer;
 import com.intellectualcrafters.plot.object.PlotMessage;
 import com.intellectualcrafters.plot.object.PlotPlayer;
@@ -20,41 +21,41 @@ public class BukkitChatManager extends ChatManager<FancyMessage> {
     }
 
     @Override
-    public void color(final PlotMessage m, final String color) {
-        m.$(this).color(ChatColor.getByChar(C.color(color).substring(1)));
+    public void color(PlotMessage message, String color) {
+        message.$(this).color(ChatColor.getByChar(C.color(color).substring(1)));
     }
 
     @Override
-    public void tooltip(final PlotMessage m, final PlotMessage... tooltips) {
-        final List<FancyMessage> lines = new ArrayList<>();
-        for (final PlotMessage tooltip : tooltips) {
+    public void tooltip(PlotMessage message, PlotMessage... tooltips) {
+        List<FancyMessage> lines = new ArrayList<>();
+        for (PlotMessage tooltip : tooltips) {
             lines.add(tooltip.$(this));
         }
-        m.$(this).formattedTooltip(lines);
+        message.$(this).formattedTooltip(lines);
     }
 
     @Override
-    public void command(final PlotMessage m, final String command) {
-        m.$(this).command(command);
+    public void command(PlotMessage message, String command) {
+        message.$(this).command(command);
     }
 
     @Override
-    public void text(final PlotMessage m, final String text) {
-        m.$(this).then(ChatColor.stripColor(text));
+    public void text(PlotMessage message, String text) {
+        message.$(this).then(ChatColor.stripColor(text));
     }
 
     @Override
-    public void send(final PlotMessage m, final PlotPlayer player) {
-        if (ConsolePlayer.isConsole(player)) {
-            player.sendMessage(m.$(this).toOldMessageFormat());
+    public void send(PlotMessage plotMessage, PlotPlayer player) {
+        if (player instanceof ConsolePlayer || !Settings.Chat.INTERACTIVE) {
+            player.sendMessage(plotMessage.$(this).toOldMessageFormat());
         } else {
-            m.$(this).send(((BukkitPlayer) player).player);
+            plotMessage.$(this).send(((BukkitPlayer) player).player);
         }
     }
 
     @Override
-    public void suggest(final PlotMessage m, final String command) {
-        m.$(this).suggest(command);
+    public void suggest(PlotMessage plotMessage, String command) {
+        plotMessage.$(this).suggest(command);
     }
 
 }

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

@@ -3,106 +3,56 @@ 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.intellectualcrafters.plot.util.Permissions;
-import com.intellectualcrafters.plot.util.StringComparison;
 import com.plotsquared.bukkit.commands.DebugUUID;
-import com.plotsquared.general.commands.Command;
-import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.command.ProxiedCommandSender;
+import org.bukkit.command.RemoteConsoleCommandSender;
 import org.bukkit.command.TabCompleter;
 import org.bukkit.entity.Player;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 
-/**
- * Created 2015-02-20 for PlotSquared
- *
-
- */
 public class BukkitCommand implements CommandExecutor, TabCompleter {
 
     public BukkitCommand() {
-        MainCommand.getInstance().addCommand(new DebugUUID());
+        new DebugUUID();
     }
 
     @Override
-    public boolean onCommand(final CommandSender commandSender, final org.bukkit.command.Command command, final String commandLabel,
-            final String[] args) {
+    public boolean onCommand(CommandSender commandSender, Command command, String commandLabel, String[] args) {
         if (commandSender instanceof Player) {
-            return MainCommand.onCommand(BukkitUtil.getPlayer((Player) commandSender), commandLabel, args);
+            return MainCommand.onCommand(BukkitUtil.getPlayer((Player) commandSender), args);
         }
-        if (commandSender == null || commandSender.getClass() == Bukkit.getConsoleSender().getClass()) {
-            return MainCommand.onCommand(ConsolePlayer.getConsole(), commandLabel, args);
+        if (commandSender instanceof ConsoleCommandSender || commandSender instanceof ProxiedCommandSender
+                || commandSender instanceof RemoteConsoleCommandSender) {
+            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 perm) {
-                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, commandLabel, args);
-        ConsolePlayer.getConsole().teleport(sender.getLocationFull());
-        return result;
+        return false;
     }
 
     @Override
-    public List<String> onTabComplete(final CommandSender commandSender, final org.bukkit.command.Command command, final String s,
-            final String[] strings) {
+    public List<String> onTabComplete(CommandSender commandSender, Command command, String s, String[] args) {
         if (!(commandSender instanceof Player)) {
             return null;
         }
-        final PlotPlayer player = BukkitUtil.getPlayer((Player) commandSender);
-        if (strings.length < 1) {
-            if ((strings.length == 0) || "plots".startsWith(s)) {
-                return Collections.singletonList("plots");
-            }
+        PlotPlayer player = BukkitUtil.getPlayer((Player) commandSender);
+        if (args.length == 0) {
+            return Collections.singletonList("plots");
         }
-        if (strings.length > 1) {
+        Collection objects = MainCommand.getInstance().tab(player, args, s.endsWith(" "));
+        if (objects == null) {
             return null;
         }
-        final Set<String> tabOptions = new HashSet<>();
-        final String arg = strings[0].toLowerCase();
-        ArrayList<String> labels = new ArrayList<>();
-        for (final Command<PlotPlayer> cmd : MainCommand.getInstance().getCommands()) {
-            final String label = cmd.getCommand();
-            HashSet<String> aliases = new HashSet<>(cmd.getAliases());
-            aliases.add(label);
-            for (String alias : aliases) {
-                labels.add(alias);
-                if (alias.startsWith(arg)) {
-                    if (Permissions.hasPermission(player, cmd.getPermission())) {
-                        tabOptions.add(label);
-                    } else {
-                        break;
-                    }
-                }
-            }
+        List<String> result = new ArrayList<>();
+        for (Object o : objects) {
+            result.add(o.toString());
         }
-        String best = new StringComparison<>(arg, labels).getBestMatch();
-        tabOptions.add(best);
-        if (!tabOptions.isEmpty()) {
-            return new ArrayList<>(tabOptions);
-        }
-        return null;
+        return result.isEmpty() ? null : result;
     }
 }

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

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

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

@@ -18,6 +18,7 @@ import com.plotsquared.bukkit.events.PlayerPlotHelperEvent;
 import com.plotsquared.bukkit.events.PlayerPlotTrustedEvent;
 import com.plotsquared.bukkit.events.PlayerTeleportToPlotEvent;
 import com.plotsquared.bukkit.events.PlotClearEvent;
+import com.plotsquared.bukkit.events.PlotComponentSetEvent;
 import com.plotsquared.bukkit.events.PlotDeleteEvent;
 import com.plotsquared.bukkit.events.PlotFlagAddEvent;
 import com.plotsquared.bukkit.events.PlotFlagRemoveEvent;
@@ -35,91 +36,96 @@ import java.util.UUID;
 
 public class BukkitEventUtil extends EventUtil {
 
-    public Player getPlayer(final PlotPlayer player) {
+    public Player getPlayer(PlotPlayer player) {
         if (player instanceof BukkitPlayer) {
             return ((BukkitPlayer) player).player;
         }
         return null;
     }
 
-    public boolean callEvent(final Event event) {
+    public boolean callEvent(Event event) {
         Bukkit.getServer().getPluginManager().callEvent(event);
         return !(event instanceof Cancellable) || !((Cancellable) event).isCancelled();
     }
 
     @Override
-    public boolean callClaim(final PlotPlayer player, final Plot plot, final boolean auto) {
+    public boolean callClaim(PlotPlayer player, Plot plot, boolean auto) {
         return callEvent(new PlayerClaimPlotEvent(getPlayer(player), plot, auto));
     }
 
     @Override
-    public boolean callTeleport(final PlotPlayer player, final Location from, final Plot plot) {
+    public boolean callTeleport(PlotPlayer player, Location from, Plot plot) {
         return callEvent(new PlayerTeleportToPlotEvent(getPlayer(player), from, plot));
     }
 
     @Override
-    public boolean callClear(final Plot plot) {
+    public boolean callComponentSet(Plot plot, String component) {
+        return callEvent(new PlotComponentSetEvent(plot, component));
+    }
+
+    @Override
+    public boolean callClear(Plot plot) {
         return callEvent(new PlotClearEvent(plot));
     }
 
     @Override
-    public void callDelete(final Plot plot) {
+    public void callDelete(Plot plot) {
         callEvent(new PlotDeleteEvent(plot));
     }
 
     @Override
-    public boolean callFlagAdd(final Flag flag, final Plot plot) {
+    public boolean callFlagAdd(Flag flag, Plot plot) {
         return callEvent(new PlotFlagAddEvent(flag, plot));
     }
 
     @Override
-    public boolean callFlagRemove(final Flag flag, final Plot plot) {
+    public boolean callFlagRemove(Flag<?> flag, Plot plot, Object value) {
         return callEvent(new PlotFlagRemoveEvent(flag, plot));
     }
 
     @Override
-    public boolean callMerge(final Plot plot, final ArrayList<PlotId> plots) {
+    public boolean callMerge(Plot plot, ArrayList<PlotId> plots) {
         return callEvent(new PlotMergeEvent(BukkitUtil.getWorld(plot.getArea().worldname), plot, plots));
     }
 
     @Override
-    public boolean callUnlink(final PlotArea area, final ArrayList<PlotId> plots) {
+    public boolean callUnlink(PlotArea area, ArrayList<PlotId> plots) {
         return callEvent(new PlotUnlinkEvent(BukkitUtil.getWorld(area.worldname), area, plots));
     }
 
     @Override
-    public void callEntry(final PlotPlayer player, final Plot plot) {
+    public void callEntry(PlotPlayer player, Plot plot) {
         callEvent(new PlayerEnterPlotEvent(getPlayer(player), plot));
     }
 
     @Override
-    public void callLeave(final PlotPlayer player, final Plot plot) {
+    public void callLeave(PlotPlayer player, Plot plot) {
         callEvent(new PlayerLeavePlotEvent(getPlayer(player), plot));
     }
 
     @Override
-    public void callDenied(final PlotPlayer initiator, final Plot plot, final UUID player, final boolean added) {
+    public void callDenied(PlotPlayer initiator, Plot plot, UUID player, boolean added) {
         callEvent(new PlayerPlotDeniedEvent(getPlayer(initiator), plot, player, added));
     }
 
     @Override
-    public void callTrusted(final PlotPlayer initiator, final Plot plot, final UUID player, final boolean added) {
+    public void callTrusted(PlotPlayer initiator, Plot plot, UUID player, boolean added) {
         callEvent(new PlayerPlotHelperEvent(getPlayer(initiator), plot, player, added));
     }
 
     @Override
-    public void callMember(final PlotPlayer initiator, final Plot plot, final UUID player, final boolean added) {
+    public void callMember(PlotPlayer initiator, Plot plot, UUID player, boolean added) {
         callEvent(new PlayerPlotTrustedEvent(getPlayer(initiator), plot, player, added));
     }
 
     @Override
-    public boolean callFlagRemove(final Flag flag, final PlotCluster cluster) {
+    public boolean callFlagRemove(Flag flag, Object object, PlotCluster cluster) {
         return callEvent(new ClusterFlagRemoveEvent(flag, cluster));
     }
 
     @Override
-    public Rating callRating(final PlotPlayer player, final Plot plot, final Rating rating) {
-        final PlotRateEvent event = new PlotRateEvent(player, rating, plot);
+    public Rating callRating(PlotPlayer player, Plot plot, Rating rating) {
+        PlotRateEvent event = new PlotRateEvent(player, rating, plot);
         Bukkit.getServer().getPluginManager().callEvent(event);
         return event.getRating();
     }

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

@@ -1,21 +1,7 @@
 package com.plotsquared.bukkit.util;
 
-import java.util.HashSet;
-import java.util.Random;
-
-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 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;
@@ -23,6 +9,19 @@ 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 com.intellectualcrafters.plot.util.block.GlobalBlockQueue;
+import com.intellectualcrafters.plot.util.block.LocalBlockQueue;
+import com.intellectualcrafters.plot.util.expiry.PlotAnalysis;
+import java.util.HashSet;
+import java.util.Random;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.generator.ChunkGenerator.BiomeGrid;
+import org.bukkit.material.Directional;
+import org.bukkit.material.MaterialData;
 
 public class BukkitHybridUtils extends HybridUtils {
 
@@ -43,6 +42,7 @@ public class BukkitHybridUtils extends HybridUtils {
         TaskManager.runTaskAsync(new Runnable() {
             @Override
             public void run() {
+                final LocalBlockQueue queue = GlobalBlockQueue.IMP.getNewQueue(world, false);
                 final World worldObj = Bukkit.getWorld(world);
                 final ChunkGenerator gen = worldObj.getGenerator();
                 if (gen == null) {
@@ -50,11 +50,10 @@ public class BukkitHybridUtils extends HybridUtils {
                 }
                 final BiomeGrid nullBiomeGrid = new BiomeGrid() {
                     @Override
-                    public void setBiome(final int a, final int b, final Biome c) {
-                    }
+                    public void setBiome(int a, int b, Biome c) {}
 
                     @Override
-                    public Biome getBiome(final int a, final int b) {
+                    public Biome getBiome(int a, int b) {
                         return null;
                     }
                 };
@@ -72,13 +71,13 @@ public class BukkitHybridUtils extends HybridUtils {
                 final int ctz = tz >> 4;
                 final Random r = new Random();
                 MainUtil.initCache();
-                final int width = (tx - bx) + 1;
-                final int length = (tz - bz) + 1;
+                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 short[][][] oldBlocks = new short[256][width][length];
+                final short[][][] newBlocks = new short[256][width][length];
 
                 final Runnable run = new Runnable() {
                     @Override
@@ -87,38 +86,38 @@ public class BukkitHybridUtils extends HybridUtils {
                             @Override
                             public void run(int[] value) {
                                 // [chunkx, chunkz, pos1x, pos1z, pos2x, pos2z, isedge]
-                                final int X = value[0];
-                                final int Z = value[1];
-                                final short[][] result = gen.generateExtBlockSections(worldObj, r, X, Z, nullBiomeGrid);
-                                final int xb = ((X) << 4) - bx;
-                                final int zb = ((Z) << 4) - bz;
+                                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++) {
-                                            final int x = MainUtil.x_loc[i][j] + xb;
-                                            if ((x < 0) || (x >= width)) {
+                                            int x = MainUtil.x_loc[i][j] + xb;
+                                            if (x < 0 || x >= width) {
                                                 continue;
                                             }
-                                            final int z = MainUtil.z_loc[i][j] + zb;
-                                            if ((z < 0) || (z >= length)) {
+                                            int z = MainUtil.z_loc[i][j] + zb;
+                                            if (z < 0 || z >= length) {
                                                 continue;
                                             }
-                                            final int y = MainUtil.y_loc[i][j];
-                                            oldblocks[y][x][z] = 0;
+                                            int y = MainUtil.y_loc[i][j];
+                                            oldBlocks[y][x][z] = 0;
                                         }
                                         continue;
                                     }
                                     for (int j = 0; j < result[i].length; j++) {
-                                        final int x = MainUtil.x_loc[i][j] + xb;
-                                        if ((x < 0) || (x >= width)) {
+                                        int x = MainUtil.x_loc[i][j] + xb;
+                                        if (x < 0 || x >= width) {
                                             continue;
                                         }
-                                        final int z = MainUtil.z_loc[i][j] + zb;
-                                        if ((z < 0) || (z >= length)) {
+                                        int z = MainUtil.z_loc[i][j] + zb;
+                                        if (z < 0 || z >= length) {
                                             continue;
                                         }
-                                        final int y = MainUtil.y_loc[i][j];
-                                        oldblocks[y][x][z] = result[i][j];
+                                        int y = MainUtil.y_loc[i][j];
+                                        oldBlocks[y][x][z] = result[i][j];
                                     }
                                 }
 
@@ -129,19 +128,19 @@ public class BukkitHybridUtils extends HybridUtils {
                                 TaskManager.runTaskAsync(new Runnable() {
                                     @Override
                                     public void run() {
-                                        final int size = width * length;
-                                        final int[] changes = new int[size];
-                                        final int[] faces = new int[size];
-                                        final int[] data = new int[size];
-                                        final int[] air = new int[size];
-                                        final int[] variety = new int[size];
+                                        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++) {
-                                                final HashSet<Short> types = new HashSet<>();
+                                                HashSet<Short> types = new HashSet<>();
                                                 for (int y = 0; y < 256; y++) {
-                                                    final short old = oldblocks[y][x][z];
-                                                    final short now = newblocks[y][x][z];
+                                                    short old = oldBlocks[y][x][z];
+                                                    short now = newBlocks[y][x][z];
                                                     if (old != now) {
                                                         changes[i]++;
                                                     }
@@ -150,29 +149,29 @@ public class BukkitHybridUtils extends HybridUtils {
                                                     } 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) {
+                                                        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) {
+                                                            if (newBlocks[y][x - 1][z] == 0) {
                                                                 faces[i]++;
                                                             }
-                                                            if (newblocks[y][x][z - 1] == 0) {
+                                                            if (newBlocks[y][x][z - 1] == 0) {
                                                                 faces[i]++;
                                                             }
-                                                            if (newblocks[y + 1][x][z] == 0) {
+                                                            if (newBlocks[y + 1][x][z] == 0) {
                                                                 faces[i]++;
                                                             }
-                                                            if (newblocks[y][x + 1][z] == 0) {
+                                                            if (newBlocks[y][x + 1][z] == 0) {
                                                                 faces[i]++;
                                                             }
-                                                            if (newblocks[y][x][z + 1] == 0) {
+                                                            if (newBlocks[y][x][z + 1] == 0) {
                                                                 faces[i]++;
                                                             }
                                                         }
 
-                                                        final Material material = Material.getMaterial(now);
-                                                        final Class<? extends MaterialData> md = material.getData();
+                                                        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)) {
@@ -189,18 +188,18 @@ public class BukkitHybridUtils extends HybridUtils {
                                         // put in analysis obj
 
                                         // run whenDone
-                                        final PlotAnalysis analysis = new PlotAnalysis();
+                                        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));
+                                        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;
@@ -218,48 +217,48 @@ public class BukkitHybridUtils extends HybridUtils {
 
                     @Override
                     public void run(int[] value) {
-                        final int X = value[0];
-                        final int Z = value[1];
+                        int X = value[0];
+                        int Z = value[1];
                         worldObj.loadChunk(X, Z);
                         int minX;
-                        int minZ;
-                        int maxX;
-                        int maxZ;
                         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;
                         }
 
-                        final int cbx = X << 4;
-                        final int cbz = Z << 4;
+                        int cbx = X << 4;
+                        int cbz = Z << 4;
 
-                        final int xb = (cbx) - bx;
-                        final int zb = (cbz) - bz;
+                        int xb = cbx - bx;
+                        int zb = cbz - bz;
                         for (int x = minX; x <= maxX; x++) {
-                            final int xx = cbx + x;
+                            int xx = cbx + x;
                             for (int z = minZ; z <= maxZ; z++) {
-                                final int zz = cbz + z;
+                                int zz = cbz + z;
                                 for (int y = 0; y < 256; y++) {
-                                    final Block block = worldObj.getBlockAt(xx, y, zz);
-                                    final int xr = xb + x;
-                                    final int zr = zb + z;
-                                    newblocks[y][xr][zr] = (short) block.getTypeId();
+                                    PlotBlock block = queue.getBlock(xx, y, zz);
+                                    int xr = xb + x;
+                                    int zr = zb + z;
+                                    newBlocks[y][xr][zr] = block.id;
                                 }
                             }
                         }
@@ -274,50 +273,4 @@ public class BukkitHybridUtils extends HybridUtils {
             }
         });
     }
-
-    @Override
-    public int checkModified(final String worldname, final int x1, final int x2, final int y1, final int y2, final int z1, final int z2,
-            final PlotBlock[] blocks) {
-        final 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++) {
-                    final Block block = world.getBlockAt(x, y, z);
-                    final int id = block.getTypeId();
-                    boolean same = false;
-                    for (final PlotBlock p : blocks) {
-                        if (id == p.id) {
-                            same = true;
-                            break;
-                        }
-                    }
-                    if (!same) {
-                        count++;
-                    }
-                }
-            }
-        }
-        return count;
-    }
-
-    @Override
-    public int get_ey(final String worldname, final int sx, final int ex, final int sz, final int ez, final int sy) {
-        final World world = BukkitUtil.getWorld(worldname);
-        final 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) {
-                        final Block block = world.getBlockAt(x, y, z);
-                        if (block.getTypeId() != 0) {
-                            ey = y;
-                        }
-                    }
-                }
-            }
-        }
-        return ey;
-    }
 }

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

@@ -19,11 +19,11 @@ import java.util.List;
 
 public class BukkitInventoryUtil extends InventoryUtil {
 
-    public static ItemStack getItem(final PlotItemStack item) {
+    public static ItemStack getItem(PlotItemStack item) {
         if (item == null) {
             return null;
         }
-        final ItemStack stack = new ItemStack(item.id, item.amount, item.data);
+        ItemStack stack = new ItemStack(item.id, item.amount, item.data);
         ItemMeta meta = null;
         if (item.name != null) {
             meta = stack.getItemMeta();
@@ -33,8 +33,8 @@ public class BukkitInventoryUtil extends InventoryUtil {
             if (meta == null) {
                 meta = stack.getItemMeta();
             }
-            final List<String> lore = new ArrayList<>();
-            for (final String entry : item.lore) {
+            List<String> lore = new ArrayList<>();
+            for (String entry : item.lore) {
                 lore.add(ChatColor.translateAlternateColorCodes('&', entry));
             }
             meta.setLore(lore);
@@ -46,12 +46,12 @@ public class BukkitInventoryUtil extends InventoryUtil {
     }
 
     @Override
-    public void open(final PlotInventory inv) {
-        final BukkitPlayer bp = (BukkitPlayer) inv.player;
-        final Inventory inventory = Bukkit.createInventory(null, inv.size * 9, inv.getTitle());
-        final PlotItemStack[] items = inv.getItems();
+    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++) {
-            final PlotItemStack item = items[i];
+            PlotItemStack item = items[i];
             if (item != null) {
                 inventory.setItem(i, getItem(item));
             }
@@ -61,19 +61,19 @@ public class BukkitInventoryUtil extends InventoryUtil {
     }
 
     @Override
-    public void close(final PlotInventory inv) {
+    public void close(PlotInventory inv) {
         if (!inv.isOpen()) {
             return;
         }
         inv.player.deleteMeta("inventory");
-        final BukkitPlayer bp = (BukkitPlayer) inv.player;
+        BukkitPlayer bp = (BukkitPlayer) inv.player;
         bp.player.closeInventory();
     }
 
     @Override
-    public void setItem(final PlotInventory inv, final int index, final PlotItemStack item) {
-        final BukkitPlayer bp = (BukkitPlayer) inv.player;
-        final InventoryView opened = bp.player.getOpenInventory();
+    public void setItem(PlotInventory inv, int index, PlotItemStack item) {
+        BukkitPlayer bp = (BukkitPlayer) inv.player;
+        InventoryView opened = bp.player.getOpenInventory();
         if (!inv.isOpen()) {
             return;
         }
@@ -81,22 +81,22 @@ public class BukkitInventoryUtil extends InventoryUtil {
         bp.player.updateInventory();
     }
 
-    public PlotItemStack getItem(final ItemStack item) {
+    public PlotItemStack getItem(ItemStack item) {
         if (item == null) {
             return null;
         }
-        final int id = item.getTypeId();
-        final short data = item.getDurability();
-        final int amount = item.getAmount();
+        int id = item.getTypeId();
+        short data = item.getDurability();
+        int amount = item.getAmount();
         String name = null;
         String[] lore = null;
         if (item.hasItemMeta()) {
-            final ItemMeta meta = item.getItemMeta();
+            ItemMeta meta = item.getItemMeta();
             if (meta.hasDisplayName()) {
                 name = meta.getDisplayName();
             }
             if (meta.hasLore()) {
-                final List<String> itemLore = meta.getLore();
+                List<String> itemLore = meta.getLore();
                 lore = itemLore.toArray(new String[itemLore.size()]);
             }
         }
@@ -104,10 +104,10 @@ public class BukkitInventoryUtil extends InventoryUtil {
     }
 
     @Override
-    public PlotItemStack[] getItems(final PlotPlayer player) {
-        final BukkitPlayer bp = (BukkitPlayer) player;
-        final PlayerInventory inv = bp.player.getInventory();
-        final PlotItemStack[] items = new PlotItemStack[36];
+    public PlotItemStack[] getItems(PlotPlayer player) {
+        BukkitPlayer bp = (BukkitPlayer) player;
+        PlayerInventory inv = bp.player.getInventory();
+        PlotItemStack[] items = new PlotItemStack[36];
         for (int i = 0; i < 36; i++) {
             items[i] = getItem(inv.getItem(i));
         }
@@ -115,12 +115,12 @@ public class BukkitInventoryUtil extends InventoryUtil {
     }
 
     @Override
-    public boolean isOpen(final PlotInventory inv) {
+    public boolean isOpen(PlotInventory inv) {
         if (!inv.isOpen()) {
             return false;
         }
-        final BukkitPlayer bp = (BukkitPlayer) inv.player;
-        final InventoryView opened = bp.player.getOpenInventory();
+        BukkitPlayer bp = (BukkitPlayer) inv.player;
+        InventoryView opened = bp.player.getOpenInventory();
         return inv.isOpen() && opened.getType() == InventoryType.CRAFTING && opened.getTitle() == null;
     }
 }

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

@@ -16,35 +16,32 @@ public class BukkitPlainChatManager extends ChatManager<List<StringBuilder>> {
     }
 
     @Override
-    public void color(final PlotMessage m, final String color) {
-        final List<StringBuilder> parts = m.$(this);
+    public void color(PlotMessage message, String color) {
+        List<StringBuilder> parts = message.$(this);
         parts.get(parts.size() - 1).insert(0, color);
     }
 
     @Override
-    public void tooltip(final PlotMessage m, final PlotMessage... tooltips) {
+    public void tooltip(PlotMessage message, PlotMessage... tooltips) {}
+
+    @Override
+    public void command(PlotMessage message, String command) {}
+
+    @Override
+    public void text(PlotMessage message, String text) {
+        message.$(this).add(new StringBuilder(ChatColor.stripColor(text)));
     }
 
     @Override
-    public void command(final PlotMessage m, final String command) {
-    }
-
-    @Override
-    public void text(final PlotMessage m, final String text) {
-        m.$(this).add(new StringBuilder(ChatColor.stripColor(text)));
-    }
-
-    @Override
-    public void send(final PlotMessage m, final PlotPlayer player) {
-        final StringBuilder built = new StringBuilder();
-        for (final StringBuilder sb : m.$(this)) {
+    public void send(PlotMessage plotMessage, PlotPlayer player) {
+        StringBuilder built = new StringBuilder();
+        for (StringBuilder sb : plotMessage.$(this)) {
             built.append(sb);
         }
         player.sendMessage(built.toString());
     }
 
     @Override
-    public void suggest(final PlotMessage m, final String command) {
-    }
+    public void suggest(PlotMessage plotMessage, String command) {}
 
 }

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

@@ -1,39 +1,5 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// 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 java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
-import org.bukkit.Bukkit;
-import org.bukkit.Chunk;
-import org.bukkit.World;
-import org.bukkit.block.Block;
-import org.bukkit.block.BlockState;
-
 import com.intellectualcrafters.jnbt.ByteArrayTag;
 import com.intellectualcrafters.jnbt.CompoundTag;
 import com.intellectualcrafters.jnbt.IntTag;
@@ -48,13 +14,23 @@ 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.intellectualcrafters.plot.util.block.LocalBlockQueue;
 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
- *
-
-
+ * Schematic Handler.
  */
 public class BukkitSchematicHandler extends SchematicHandler {
 
@@ -67,11 +43,11 @@ public class BukkitSchematicHandler extends SchematicHandler {
                 // Main positions
                 Location[] corners = MainUtil.getCorners(world, regions);
                 final Location bot = corners[0];
-                final Location top = corners[1];
+                Location top = corners[1];
 
-                final int width = (top.getX() - bot.getX()) + 1;
-                final int height = (top.getY() - bot.getY()) + 1;
-                final int length = (top.getZ() - bot.getZ()) + 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));
@@ -85,7 +61,7 @@ public class BukkitSchematicHandler extends SchematicHandler {
                 schematic.put("WEOffsetY", new IntTag("WEOffsetY", 0));
                 schematic.put("WEOffsetZ", new IntTag("WEOffsetZ", 0));
                 // Arrays of data types
-                final List<Tag> tileEntities = new ArrayList<>();
+                final List<CompoundTag> tileEntities = new ArrayList<>();
                 final byte[] blocks = new byte[width * height * length];
                 final byte[] blockData = new byte[width * height * length];
                 // Queue
@@ -137,16 +113,16 @@ public class BukkitSchematicHandler extends SchematicHandler {
                         TaskManager.runTask(new Runnable() {
                             @Override
                             public void run() {
-                                final long start = System.currentTimeMillis();
-                                while ((!chunks.isEmpty()) && ((System.currentTimeMillis() - start) < 20)) {
+                                long start = System.currentTimeMillis();
+                                while (!chunks.isEmpty() && System.currentTimeMillis() - start < 20) {
                                     // save schematics
-                                    final ChunkLoc chunk = chunks.remove(0);
-                                    final Chunk bc = worldObj.getChunkAt(chunk.x, chunk.z);
+                                    ChunkLoc chunk = chunks.remove(0);
+                                    Chunk bc = worldObj.getChunkAt(chunk.x, chunk.z);
                                     if (!bc.load(false)) {
                                         continue;
                                     }
-                                    final int X = chunk.x;
-                                    final int Z = chunk.z;
+                                    int X = chunk.x;
+                                    int Z = chunk.z;
                                     int xxb = X << 4;
                                     int zzb = Z << 4;
                                     int xxt = xxb + 15;
@@ -165,16 +141,16 @@ public class BukkitSchematicHandler extends SchematicHandler {
                                         zzt = p2z;
                                     }
                                     for (int y = sy; y <= Math.min(255, ey); y++) {
-                                        final int ry = y - sy;
-                                        final int i1 = (ry * width * length);
+                                        int ry = y - sy;
+                                        int i1 = ry * width * length;
                                         for (int z = zzb; z <= zzt; z++) {
-                                            final int rz = z - bz;
-                                            final int i2 = i1 + (rz * width);
+                                            int rz = z - bz;
+                                            int i2 = i1 + rz * width;
                                             for (int x = xxb; x <= xxt; x++) {
-                                                final int rx = x - bx;
-                                                final int index = i2 + rx;
-                                                final Block block = worldObj.getBlockAt(x, y, z);
-                                                final int id = block.getTypeId();
+                                                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:
@@ -243,9 +219,8 @@ public class BukkitSchematicHandler extends SchematicHandler {
                                                     case 189:
                                                     case 190:
                                                     case 191:
-                                                    case 192: {
+                                                    case 192:
                                                         break;
-                                                    }
                                                     case 54:
                                                     case 130:
                                                     case 142:
@@ -280,29 +255,24 @@ public class BukkitSchematicHandler extends SchematicHandler {
                                                     case 29:
                                                     case 33:
                                                     case 151:
-                                                    case 178: {
+                                                    case 178:
                                                         // TODO implement fully
-                                                        final BlockState state = block.getState();
+                                                        BlockState state = block.getState();
                                                         if (state != null) {
-                                                            final StateWrapper wrapper = new StateWrapper(state);
-                                                            final CompoundTag rawTag = wrapper.getTag();
+                                                            StateWrapper wrapper = new StateWrapper(state);
+                                                            CompoundTag rawTag = wrapper.getTag();
                                                             if (rawTag != null) {
-                                                                final Map<String, Tag> values = new HashMap<String, Tag>();
-                                                                for (final Entry<String, Tag> entry : rawTag.getValue().entrySet()) {
-                                                                    values.put(entry.getKey(), entry.getValue());
-                                                                }
+                                                                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));
-                                                                final CompoundTag tileEntityTag = new CompoundTag(values);
+                                                                CompoundTag tileEntityTag = new CompoundTag(values);
                                                                 tileEntities.add(tileEntityTag);
                                                             }
                                                         }
-                                                    }
-                                                    default: {
+                                                    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
@@ -334,7 +304,7 @@ public class BukkitSchematicHandler extends SchematicHandler {
     }
 
     @Override
-    public void restoreTag(CompoundTag ct, short x, short y, short z, Schematic schem) {
-        new StateWrapper(ct).restoreTag(x, y, z, schem);
+    public boolean restoreTile(LocalBlockQueue queue, CompoundTag ct, int x, int y, int z) {
+        return new StateWrapper(ct).restoreTag(queue.getWorld(), x, y, z);
     }
 }

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

@@ -29,13 +29,13 @@ public class BukkitSetupUtils extends SetupUtils {
         if (!SetupUtils.generators.isEmpty()) {
             return;
         }
-        final String testWorld = "CheckingPlotSquaredGenerator";
-        for (final Plugin plugin : Bukkit.getPluginManager().getPlugins()) {
+        String testWorld = "CheckingPlotSquaredGenerator";
+        for (Plugin plugin : Bukkit.getPluginManager().getPlugins()) {
             if (plugin.isEnabled()) {
-                final ChunkGenerator generator = plugin.getDefaultWorldGenerator(testWorld, "");
+                ChunkGenerator generator = plugin.getDefaultWorldGenerator(testWorld, "");
                 if (generator != null) {
                     PS.get().removePlotAreas(testWorld);
-                    final String name = plugin.getDescription().getName();
+                    String name = plugin.getDescription().getName();
                     GeneratorWrapper<?> wrapped;
                     if (generator instanceof GeneratorWrapper<?>) {
                         wrapped = (GeneratorWrapper<?>) generator;
@@ -49,33 +49,33 @@ public class BukkitSetupUtils extends SetupUtils {
     }
 
     @Override
-    public String setupWorld(final SetupObject object) {
+    public String setupWorld(SetupObject object) {
         SetupUtils.manager.updateGenerators();
         ConfigurationNode[] steps = object.step == null ? new ConfigurationNode[0] : object.step;
-        final String world = object.world;
+        String world = object.world;
         int type = object.type;
         String worldPath = "worlds." + object.world;
-        if (!PS.get().config.contains(worldPath)) {
-            PS.get().config.createSection(worldPath);
+        if (!PS.get().worlds.contains(worldPath)) {
+            PS.get().worlds.createSection(worldPath);
         }
-        ConfigurationSection worldSection = PS.get().config.getConfigurationSection(worldPath);
+        ConfigurationSection worldSection = PS.get().worlds.getConfigurationSection(worldPath);
         switch (type) {
             case 2: {
                 if (object.id != null) {
-                    String areaname = object.id + "-" + object.min + "-" + object.max;
-                    String areaPath = "areas." + areaname;
+                    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 (final ConfigurationNode step : steps) {
+                    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)) {
+                    if (object.setupGenerator != null && !object.setupGenerator.equals(object.plotManager)) {
                         options.put("generator.init", object.setupGenerator);
                     }
                     for (Entry<String, Object> entry : options.entrySet()) {
@@ -91,42 +91,40 @@ public class BukkitSetupUtils extends SetupUtils {
                         }
                     }
                 }
-                GeneratorWrapper<?> gen = generators.get(object.setupGenerator);
-                if ((gen != null) && gen.isFull()) {
+                GeneratorWrapper<?> gen = SetupUtils.generators.get(object.setupGenerator);
+                if (gen != null && gen.isFull()) {
                     object.setupGenerator = null;
                 }
                 break;
             }
-            case 1: {
-                for (final ConfigurationNode step : steps) {
+            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);
+                PS.get().worlds.set("worlds." + world + ".generator.type", object.type);
+                PS.get().worlds.set("worlds." + world + ".generator.terrain", object.terrain);
+                PS.get().worlds.set("worlds." + world + ".generator.plugin", object.plotManager);
+                if (object.setupGenerator != null && !object.setupGenerator.equals(object.plotManager)) {
+                    PS.get().worlds.set("worlds." + world + ".generator.init", object.setupGenerator);
                 }
-                GeneratorWrapper<?> gen = generators.get(object.setupGenerator);
-                if ((gen != null) && gen.isFull()) {
+                GeneratorWrapper<?> gen = SetupUtils.generators.get(object.setupGenerator);
+                if (gen != null && gen.isFull()) {
                     object.setupGenerator = null;
                 }
                 break;
-            }
-            case 0: {
-                for (final ConfigurationNode step : steps) {
+            case 0:
+                for (ConfigurationNode step : steps) {
                     worldSection.set(step.getConstant(), step.getValue());
                 }
                 break;
-            }
         }
         try {
-            PS.get().config.save(PS.get().configFile);
-        } catch (final IOException e) {
+            PS.get().worlds.save(PS.get().worldsFile);
+        } catch (IOException e) {
             e.printStackTrace();
         }
         if (object.setupGenerator != null) {
-            if ((Bukkit.getPluginManager().getPlugin("Multiverse-Core") != null) && Bukkit.getPluginManager().getPlugin("Multiverse-Core")
+            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);
@@ -135,27 +133,27 @@ public class BukkitSetupUtils extends SetupUtils {
                     return world;
                 }
             }
-            if ((Bukkit.getPluginManager().getPlugin("MultiWorld") != null) && Bukkit.getPluginManager().getPlugin("MultiWorld").isEnabled()) {
+            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;
                 }
             }
-            final WorldCreator wc = new WorldCreator(object.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")
+            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()) {
+            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;
@@ -166,34 +164,34 @@ public class BukkitSetupUtils extends SetupUtils {
         return object.world;
     }
 
-    public void setGenerator(final String world, final String generator) {
-        if ((Bukkit.getWorlds().isEmpty()) || !Bukkit.getWorlds().get(0).getName().equals(world)) {
+    public void setGenerator(String world, String generator) {
+        if (Bukkit.getWorlds().isEmpty() || !Bukkit.getWorlds().get(0).getName().equals(world)) {
             return;
         }
-        final File file = new File("bukkit.yml").getAbsoluteFile();
-        final YamlConfiguration yml = YamlConfiguration.loadConfiguration(file);
+        File file = new File("bukkit.yml").getAbsoluteFile();
+        YamlConfiguration yml = YamlConfiguration.loadConfiguration(file);
         yml.set("worlds." + world + ".generator", generator);
         try {
             yml.save(file);
-        } catch (final IOException e) {
+        } catch (IOException e) {
             e.printStackTrace();
         }
     }
 
     @Override
-    public String getGenerator(final PlotArea plotworld) {
+    public String getGenerator(PlotArea plotArea) {
         if (SetupUtils.generators.isEmpty()) {
             updateGenerators();
         }
-        final World world = Bukkit.getWorld(plotworld.worldname);
+        World world = Bukkit.getWorld(plotArea.worldname);
         if (world == null) {
             return null;
         }
-        final ChunkGenerator generator = world.getGenerator();
+        ChunkGenerator generator = world.getGenerator();
         if (!(generator instanceof BukkitPlotGenerator)) {
             return null;
         }
-        for (final Entry<String, GeneratorWrapper<?>> entry : generators.entrySet()) {
+        for (Entry<String, GeneratorWrapper<?>> entry : SetupUtils.generators.entrySet()) {
             GeneratorWrapper<?> current = entry.getValue();
             if (current.equals(generator)) {
                 return entry.getKey();

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

@@ -6,38 +6,45 @@ 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);
-    }
+    private final BukkitMain bukkitMain;
 
-    @SuppressWarnings("deprecation") @Override
-    public int taskRepeatAsync(final Runnable r, final int interval) {
-        return BukkitMain.THIS.getServer().getScheduler().scheduleAsyncRepeatingTask(BukkitMain.THIS, r, interval, interval);
+    public BukkitTaskManager(BukkitMain bukkitMain) {
+        this.bukkitMain = bukkitMain;
     }
 
     @Override
-    public void taskAsync(final Runnable r) {
-        BukkitMain.THIS.getServer().getScheduler().runTaskAsynchronously(BukkitMain.THIS, r).getTaskId();
+    public int taskRepeat(Runnable runnable, int interval) {
+        return this.bukkitMain.getServer().getScheduler().scheduleSyncRepeatingTask(this.bukkitMain, runnable, interval, interval);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public int taskRepeatAsync(Runnable runnable, int interval) {
+        return this.bukkitMain.getServer().getScheduler().scheduleAsyncRepeatingTask(this.bukkitMain, runnable, interval, interval);
     }
 
     @Override
-    public void task(final Runnable r) {
-        BukkitMain.THIS.getServer().getScheduler().runTask(BukkitMain.THIS, r).getTaskId();
+    public void taskAsync(Runnable runnable) {
+        this.bukkitMain.getServer().getScheduler().runTaskAsynchronously(this.bukkitMain, runnable).getTaskId();
     }
 
     @Override
-    public void taskLater(final Runnable r, final int delay) {
-        BukkitMain.THIS.getServer().getScheduler().runTaskLater(BukkitMain.THIS, r, delay).getTaskId();
+    public void task(Runnable runnable) {
+        this.bukkitMain.getServer().getScheduler().runTask(this.bukkitMain, runnable).getTaskId();
     }
 
     @Override
-    public void taskLaterAsync(final Runnable r, final int delay) {
-        BukkitMain.THIS.getServer().getScheduler().runTaskLaterAsynchronously(BukkitMain.THIS, r, delay);
+    public void taskLater(Runnable runnable, int delay) {
+        this.bukkitMain.getServer().getScheduler().runTaskLater(this.bukkitMain, runnable, delay).getTaskId();
     }
 
     @Override
-    public void cancelTask(final int task) {
+    public void taskLaterAsync(Runnable runnable, int delay) {
+        this.bukkitMain.getServer().getScheduler().runTaskLaterAsynchronously(this.bukkitMain, runnable, delay);
+    }
+
+    @Override
+    public void cancelTask(int task) {
         if (task != -1) {
             Bukkit.getScheduler().cancelTask(task);
         }

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

@@ -5,9 +5,18 @@ 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.*;
+import com.intellectualcrafters.plot.util.MathMan;
+import com.intellectualcrafters.plot.util.StringComparison;
+import com.intellectualcrafters.plot.util.StringMan;
+import com.intellectualcrafters.plot.util.UUIDHandler;
+import com.intellectualcrafters.plot.util.WorldUtil;
 import com.plotsquared.bukkit.object.BukkitPlayer;
-import org.bukkit.*;
+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;
@@ -17,10 +26,12 @@ import org.bukkit.entity.Player;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.InventoryHolder;
 import org.bukkit.inventory.ItemStack;
-import org.bukkit.material.*;
-
-import java.util.Arrays;
-import java.util.List;
+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 {
 
@@ -30,28 +41,28 @@ public class BukkitUtil extends WorldUtil {
     private static Player lastPlayer = null;
     private static PlotPlayer lastPlotPlayer = null;
 
-    public static void removePlayer(final String plr) {
+    public static void removePlayer(String player) {
         lastPlayer = null;
         lastPlotPlayer = null;
     }
 
-    public static PlotPlayer getPlayer(final OfflinePlayer op) {
+    public static PlotPlayer getPlayer(OfflinePlayer op) {
         if (op.isOnline()) {
             return getPlayer(op.getPlayer());
         }
-        final Player player = OfflinePlayerUtil.loadPlayer(op);
+        Player player = OfflinePlayerUtil.loadPlayer(op);
         player.loadData();
         return new BukkitPlayer(player, true);
     }
 
-    public static PlotPlayer getPlayer(final Player player) {
+    public static PlotPlayer getPlayer(Player player) {
         if (player == lastPlayer) {
             return lastPlotPlayer;
         }
-        final String name = player.getName();
-        final PlotPlayer pp = UUIDHandler.getPlayer(name);
-        if (pp != null) {
-            return pp;
+        String name = player.getName();
+        PlotPlayer plotPlayer = UUIDHandler.getPlayer(name);
+        if (plotPlayer != null) {
+            return plotPlayer;
         }
         lastPlotPlayer = new BukkitPlayer(player);
         UUIDHandler.getPlayers().put(name, lastPlotPlayer);
@@ -59,84 +70,79 @@ public class BukkitUtil extends WorldUtil {
         return lastPlotPlayer;
     }
 
-    public static Location getLocation(final org.bukkit.Location loc) {
-        return new Location(loc.getWorld().getName(), MathMan.roundInt(loc.getX()), MathMan.roundInt(loc.getY()), MathMan.roundInt(loc.getZ()));
+    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(final Location loc) {
-        return new org.bukkit.Location(getWorld(loc.getWorld()), loc.getX(), loc.getY(), loc.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(final String string) {
+    public static World getWorld(String string) {
         if (StringMan.isEqual(string, lastString)) {
             if (lastWorld != null) {
                 return lastWorld;
             }
         }
-        final World world = Bukkit.getWorld(string);
+        World world = Bukkit.getWorld(string);
         lastString = string;
         lastWorld = world;
         return world;
     }
 
-    public static String getWorld(final Entity entity) {
+    public static String getWorld(Entity entity) {
         return entity.getWorld().getName();
     }
 
-    public static List<Entity> getEntities(final String worldname) {
-        return getWorld(worldname).getEntities();
+    public static List<Entity> getEntities(String worldName) {
+        return getWorld(worldName).getEntities();
     }
 
-    public static Location getLocation(final Entity entity) {
-        final org.bukkit.Location loc = entity.getLocation();
-        final String world = loc.getWorld().getName();
-        return new Location(world, loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
+    public static Location getLocation(Entity entity) {
+        org.bukkit.Location location = entity.getLocation();
+        String world = location.getWorld().getName();
+        return new Location(world, location.getBlockX(), location.getBlockY(), location.getBlockZ());
     }
 
-    public static Location getLocationFull(final Entity entity) {
-        final 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());
+    public static Location getLocationFull(Entity entity) {
+        org.bukkit.Location location = entity.getLocation();
+        return new Location(location.getWorld().getName(), MathMan.roundInt(location.getX()), MathMan.roundInt(location.getY()), MathMan.roundInt(location.getZ()),
+                location.getYaw(), location.getPitch());
     }
 
     @Override
-    public boolean isWorld(final String world) {
-        return getWorld(world) != null;
+    public boolean isWorld(String worldName) {
+        return getWorld(worldName) != null;
     }
 
     @Override
-    public String getBiome(final String world, final int x, final int z) {
+    public String getBiome(String world, int x, int z) {
         return getWorld(world).getBiome(x, z).name();
     }
 
     @Override
-    public void setSign(final String worldname, final int x, final int y, final int z, final String[] lines) {
-        final World world = getWorld(worldname);
-        final Block block = world.getBlockAt(x, y, z);
+    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);
-        final BlockState blockstate = block.getState();
+        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(final Location loc) {
-        final Block block = getWorld(loc.getWorld()).getBlockAt(loc.getX(), loc.getY(), loc.getZ());
+    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) {
-                final Sign sign = (Sign) block.getState();
+                Sign sign = (Sign) block.getState();
                 return sign.getLines();
             }
         }
@@ -144,30 +150,51 @@ public class BukkitUtil extends WorldUtil {
     }
 
     @Override
-    public Location getSpawn(final String world) {
-        final org.bukkit.Location temp = getWorld(world).getSpawnLocation();
+    public Location getSpawn(PlotPlayer player) {
+        return getLocation(((BukkitPlayer) player).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 int getHighestBlock(final String world, final int x, final int z) {
+    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(final String biomeStr) {
+    public int getBiomeFromString(String biomeString) {
         try {
-            final Biome biome = Biome.valueOf(biomeStr.toUpperCase());
+            Biome biome = Biome.valueOf(biomeString.toUpperCase());
             return Arrays.asList(Biome.values()).indexOf(biome);
-        } catch (final IllegalArgumentException e) {
+        } catch (IllegalArgumentException ignored) {
             return -1;
         }
     }
 
     @Override
     public String[] getBiomeList() {
-        final Biome[] biomes = Biome.values();
-        final String[] list = new String[biomes.length];
+        Biome[] biomes = Biome.values();
+        String[] list = new String[biomes.length];
         for (int i = 0; i < biomes.length; i++) {
             list[i] = biomes[i].name();
         }
@@ -175,18 +202,18 @@ public class BukkitUtil extends WorldUtil {
     }
 
     @Override
-    public boolean addItems(final String worldname, final PlotItem items) {
-        final World world = getWorld(worldname);
-        final Block block = world.getBlockAt(items.x, items.y, items.z);
+    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;
         }
-        final BlockState state = block.getState();
+        BlockState state = block.getState();
         if (state instanceof InventoryHolder) {
-            final InventoryHolder holder = (InventoryHolder) state;
-            final Inventory inv = holder.getInventory();
+            InventoryHolder holder = (InventoryHolder) state;
+            Inventory inv = holder.getInventory();
             for (int i = 0; i < items.id.length; i++) {
-                final ItemStack item = new ItemStack(items.id[i], items.amount[i], items.data[i]);
+                ItemStack item = new ItemStack(items.id[i], items.amount[i], items.data[i]);
                 inv.addItem(item);
             }
             state.update(true);
@@ -196,11 +223,11 @@ public class BukkitUtil extends WorldUtil {
     }
 
     @Override
-    public boolean isBlockSolid(final PlotBlock block) {
+    public boolean isBlockSolid(PlotBlock block) {
         try {
-            final Material material = Material.getMaterial(block.id);
+            Material material = Material.getMaterial(block.id);
             if (material.isBlock() && material.isSolid() && !material.hasGravity()) {
-                final Class<? extends MaterialData> data = material.getData();
+                Class<? extends MaterialData> data = material.getData();
                 if (data.equals(MaterialData.class) && !material.isTransparent() && material.isOccluding()
                         || data.equals(Tree.class)
                         || data.equals(Sandstone.class)
@@ -217,16 +244,16 @@ public class BukkitUtil extends WorldUtil {
                 }
             }
             return false;
-        } catch (final Exception e) {
+        } catch (Exception ignored) {
             return false;
         }
     }
 
     @Override
-    public String getClosestMatchingName(final PlotBlock block) {
+    public String getClosestMatchingName(PlotBlock block) {
         try {
             return Material.getMaterial(block.id).name();
-        } catch (final Exception e) {
+        } catch (Exception ignored) {
             return null;
         }
     }
@@ -234,13 +261,12 @@ public class BukkitUtil extends WorldUtil {
     @Override
     public StringComparison<PlotBlock>.ComparisonResult getClosestBlock(String name) {
         try {
-            final Material material = Material.valueOf(name.toUpperCase());
-            return new StringComparison<PlotBlock>().new ComparisonResult(0, new PlotBlock((short) material.getId(), (byte) 0));
-        } catch (IllegalArgumentException e) {
-        }
+            Material material = Material.valueOf(name.toUpperCase());
+            return new StringComparison<PlotBlock>().new ComparisonResult(0, PlotBlock.get((short) material.getId(), (byte) 0));
+        } catch (IllegalArgumentException ignored) {}
         try {
             byte data;
-            final String[] split = name.split(":");
+            String[] split = name.split(":");
             if (split.length == 2) {
                 data = Byte.parseByte(split[1]);
                 name = split[0];
@@ -253,23 +279,22 @@ public class BukkitUtil extends WorldUtil {
                 id = Short.parseShort(split[0]);
                 match = 0;
             } else {
-                final StringComparison<Material>.ComparisonResult comparison = new StringComparison<>(name, Material.values()).getBestMatchAdvanced();
+                StringComparison<Material>.ComparisonResult comparison = new StringComparison<>(name, Material.values()).getBestMatchAdvanced();
                 match = comparison.match;
                 id = (short) comparison.best.getId();
             }
-            final PlotBlock block = new PlotBlock(id, data);
-            final StringComparison<PlotBlock> outer = new StringComparison<>();
+            PlotBlock block = PlotBlock.get(id, data);
+            StringComparison<PlotBlock> outer = new StringComparison<>();
             return outer.new ComparisonResult(match, block);
 
-        } catch (NumberFormatException e) {
-        }
+        } catch (NumberFormatException ignored) {}
         return null;
     }
 
     @Override
-    public void setBiomes(final String worldname, RegionWrapper region, final String biomeStr) {
-        final World world = getWorld(worldname);
-        final Biome biome = Biome.valueOf(biomeStr.toUpperCase());
+    public void setBiomes(String worldName, RegionWrapper region, String biomeString) {
+        World world = getWorld(worldName);
+        Biome biome = Biome.valueOf(biomeString.toUpperCase());
         for (int x = region.minX; x <= region.maxX; x++) {
             for (int z = region.minZ; z <= region.maxZ; z++) {
                 world.setBiome(x, z, biome);
@@ -278,13 +303,13 @@ public class BukkitUtil extends WorldUtil {
     }
 
     @Override
-    public PlotBlock getBlock(final Location loc) {
-        final World world = getWorld(loc.getWorld());
-        final Block block = world.getBlockAt(loc.getX(), loc.getY(), loc.getZ());
+    public PlotBlock getBlock(Location location) {
+        World world = getWorld(location.getWorld());
+        Block block = world.getBlockAt(location.getX(), location.getY(), location.getZ());
         if (block == null) {
-            return new PlotBlock((short) 0, (byte) 0);
+            return PlotBlock.EVERYTHING;
         }
-        return new PlotBlock((short) block.getTypeId(), block.getData());
+        return PlotBlock.get((short) block.getTypeId(), block.getData());
     }
 
     @Override

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,110 +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
-        configurationFile = getConfigFile();
-        configuration = YamlConfiguration.loadConfiguration(configurationFile);
-        // add some defaults
-        configuration.addDefault("opt-out", false);
-        configuration.addDefault("guid", UUID.randomUUID().toString());
-        configuration.addDefault("debug", false);
-        // Do we need to create the file?
-        if (configuration.get("guid", null) == null) {
-            configuration.options().header("http://mcstats.org").copyDefaults(true);
-            configuration.save(configurationFile);
-        }
-        // Load the guid then
-        guid = configuration.getString("guid");
-        debug = 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) {}
             }
         }
         return baos.toByteArray();
@@ -157,16 +108,15 @@ public class Metrics {
      * @param key
      * @param value
      *
-     * @throws UnsupportedEncodingException
      */
-    private static void appendJSONPair(final StringBuilder json, final String key, final String value) {
+    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 ignored) {
             isValueNumeric = false;
         }
         if (json.charAt(json.length() - 1) != '{') {
@@ -188,11 +138,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 '\\':
@@ -213,7 +163,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);
@@ -232,7 +182,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");
     }
 
@@ -244,14 +194,14 @@ 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
-        graphs.add(graph);
+        this.graphs.add(graph);
         // and return back
         return graph;
     }
@@ -261,11 +211,11 @@ 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");
         }
-        graphs.add(graph);
+        this.graphs.add(graph);
     }
 
     /**
@@ -276,135 +226,57 @@ public class Metrics {
      * @return True if statistics measuring is running, otherwise false.
      */
     public boolean start() {
-        synchronized (optOutLock) {
-            // Did we opt out?
-            if (isOptOut()) {
-                return false;
-            }
-            // Is metrics already running?
-            if (task != null) {
-                return true;
-            }
-            // Begin hitting the server with glorious data
-            task = plugin.getServer().getScheduler().runTaskTimerAsynchronously(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 (optOutLock) {
-                            // Disable Task, if it is running and the
-                            // server
-                            // owner decided to opt-out
-                            if (isOptOut() && task != null) {
-                                task.cancel();
-                                task = null;
-                                // Tell all plotters to stop gathering
-                                // information.
-                                for (final Graph graph : 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(!firstPost);
-                        // After the first post we set firstPost to
-                        // false
-                        // Each post thereafter will be a ping
-                        firstPost = false;
-                    } catch (final IOException e) {
-                        if (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 (optOutLock) {
-            try {
-                // Reload the metrics file
-                configuration.load(getConfigFile());
-            } catch (final IOException ex) {
-                if (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 (debug) {
-                    Bukkit.getLogger().log(Level.INFO, "[Metrics] " + ex.getMessage());
-                }
-                return true;
             }
-            return configuration.getBoolean("opt-out", false);
-        }
+        }, 0, PING_INTERVAL * 1200);
+        return true;
     }
 
     /**
      * Enables metrics for the server by setting "opt-out" to false in the config file and starting the metrics task.
-     *
-     * @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 (optOutLock) {
-            // Check if the server owner has already set opt-out, if not, set
-            // it.
-            if (isOptOut()) {
-                configuration.set("opt-out", false);
-                configuration.save(configurationFile);
-            }
-            // Enable Task, if it is not running
-            if (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 (optOutLock) {
-            // Check if the server owner has already set opt-out, if not, set
-            // it.
-            if (!isOptOut()) {
-                configuration.set("opt-out", true);
-                configuration.save(configurationFile);
-            }
-            // Disable Task, if it is running
-            if (task != null) {
-                task.cancel();
-                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
      */
@@ -415,26 +287,21 @@ public class Metrics {
         // plugin.getDataFolder() => base/plugins/PluginA/
         // pluginsFolder => base/plugins/
         // The base is not necessarily relative to the startup directory.
-        final File pluginsFolder = 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 = 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) {
@@ -443,24 +310,24 @@ public class Metrics {
                 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
-        appendJSONPair(json, "guid", guid);
+        // 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";
@@ -475,8 +342,8 @@ public class Metrics {
         if (isPing) {
             appendJSONPair(json, "ping", "1");
         }
-        if (!graphs.isEmpty()) {
-            synchronized (graphs) {
+        if (!this.graphs.isEmpty()) {
+            synchronized (this.graphs) {
                 json.append(',');
                 json.append('"');
                 json.append("graphs");
@@ -484,10 +351,10 @@ public class Metrics {
                 json.append(':');
                 json.append('{');
                 boolean firstGraph = true;
-                for (final Graph graph : 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('}');
@@ -505,7 +372,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
@@ -515,8 +382,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");
@@ -525,36 +392,44 @@ public class Metrics {
         connection.addRequestProperty("Accept", "application/json");
         connection.addRequestProperty("Connection", "close");
         connection.setDoOutput(true);
-        if (debug) {
+        if (this.debug) {
             PS.debug("[Metrics] Prepared request for " + pluginName + " uncompressed=" + uncompressed.length + " compressed=" + compressed.length);
         }
-        // Write the data
-        String response;
-        try (OutputStream os = connection.getOutputStream();
-                BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
-            os.write(compressed);
-            os.flush();
-            // Now read the response
-            response = reader.readLine();
-        }
-        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 ("1".equals(response) || response.contains("This is your first update this hour")) {
-                synchronized (graphs) {
-                    for (final Graph graph : 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 +442,7 @@ public class Metrics {
         try {
             Class.forName("mineshafter.MineServer");
             return true;
-        } catch (ClassNotFoundException e) {
+        } catch (ClassNotFoundException ignored) {
             return false;
         }
     }
@@ -587,7 +462,7 @@ public class Metrics {
          */
         private final Set<Plotter> plotters = new LinkedHashSet<>();
 
-        private Graph(final String name) {
+        private Graph(String name) {
             this.name = name;
         }
 
@@ -597,7 +472,7 @@ public class Metrics {
          * @return the Graph's name
          */
         public String getName() {
-            return name;
+            return this.name;
         }
 
         /**
@@ -605,8 +480,8 @@ public class Metrics {
          *
          * @param plotter the plotter to add to the graph
          */
-        public void addPlotter(final Plotter plotter) {
-            plotters.add(plotter);
+        public void addPlotter(Plotter plotter) {
+            this.plotters.add(plotter);
         }
 
         /**
@@ -614,44 +489,39 @@ public class Metrics {
          *
          * @param plotter the plotter to remove from the graph
          */
-        public void removePlotter(final Plotter plotter) {
-            plotters.remove(plotter);
+        public void removePlotter(Plotter plotter) {
+            this.plotters.remove(plotter);
         }
 
         /**
          * Gets an <b>unmodifiable</b> set of the plotter objects in the graph
          *
-         * @return an unmodifiable {@link java.util.Set} of the plotter objects
+         * @return an unmodifiable {@link Set} of the plotter objects
          */
         public Set<Plotter> getPlotters() {
-            return Collections.unmodifiableSet(plotters);
+            return Collections.unmodifiableSet(this.plotters);
         }
 
         @Override
         public int hashCode() {
-            return name.hashCode();
+            return this.name.hashCode();
         }
 
         @Override
-        public boolean equals(final Object object) {
+        public boolean equals(Object object) {
             if (!(object instanceof Graph)) {
                 return false;
             }
-            final Graph graph = (Graph) object;
-            return graph.name.equals(name);
+            Graph graph = (Graph) object;
+            return graph.name.equals(this.name);
         }
 
-        /**
-         * Called when the server owner decides to opt-out of BukkitMetrics while the server is running.
-         */
-        protected void onOptOut() {
-        }
     }
 
     /**
      * Interface used to collect custom data for a plugin
      */
-    public static abstract class Plotter {
+    public abstract static class Plotter {
 
         /**
          * The plot's name
@@ -670,7 +540,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;
         }
 
@@ -689,14 +559,13 @@ public class Metrics {
          * @return the plotted point's column name
          */
         public String getColumnName() {
-            return name;
+            return this.name;
         }
 
         /**
          * Called after the website graphs have been updated
          */
-        public void reset() {
-        }
+        public void reset() {}
 
         @Override
         public int hashCode() {
@@ -704,12 +573,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(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/NbtFactory.java

@@ -6,21 +6,38 @@ import com.google.common.collect.HashBiMap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.MapMaker;
 import com.google.common.io.ByteSink;
+import com.google.common.io.ByteSource;
 import com.google.common.io.Closeables;
 import com.google.common.io.Files;
-import com.google.common.io.InputSupplier;
 import com.google.common.primitives.Primitives;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.Server;
 import org.bukkit.inventory.ItemStack;
 
-import java.io.*;
+import java.io.BufferedInputStream;
+import java.io.DataInput;
+import java.io.DataInputStream;
+import java.io.DataOutput;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
 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.*;
+import java.util.AbstractList;
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.ConcurrentMap;
 import java.util.zip.GZIPInputStream;
 import java.util.zip.GZIPOutputStream;
@@ -48,39 +65,43 @@ public class NbtFactory {
     // Loading/saving compounds
     private LoadCompoundMethod LOAD_COMPOUND;
     private Method SAVE_COMPOUND;
+
     /**
      * Construct an instance of the NBT factory by deducing the class of NBTBase.
      */
     private NbtFactory() {
-        if (BASE_CLASS == null) {
+        if (this.BASE_CLASS == null) {
             try {
                 // Keep in mind that I do use hard-coded field names - but it's okay as long as we're dealing
                 // with CraftBukkit or its derivatives. This does not work in MCPC+ however.
-                final ClassLoader loader = NbtFactory.class.getClassLoader();
+                ClassLoader loader = NbtFactory.class.getClassLoader();
 
-                final String packageName = getPackageName();
-                final Class<?> offlinePlayer = loader.loadClass(packageName + ".CraftOfflinePlayer");
+                String packageName = getPackageName();
+                Class<?> offlinePlayer = loader.loadClass(packageName + ".CraftOfflinePlayer");
 
                 // Prepare NBT
-                COMPOUND_CLASS = getMethod(0, Modifier.STATIC, offlinePlayer, "getData").getReturnType();
-                BASE_CLASS = COMPOUND_CLASS.getSuperclass();
-                NBT_GET_TYPE = getMethod(0, Modifier.STATIC, BASE_CLASS, "getTypeId");
-                NBT_CREATE_TAG = getMethod(Modifier.STATIC, 0, BASE_CLASS, "createTag", byte.class);
+                this.COMPOUND_CLASS = getMethod(0, Modifier.STATIC, offlinePlayer, "getData").getReturnType();
+                this.BASE_CLASS = this.COMPOUND_CLASS.getSuperclass();
+                this.NBT_GET_TYPE = getMethod(0, Modifier.STATIC, this.BASE_CLASS, "getTypeId");
+                this.NBT_CREATE_TAG = getMethod(Modifier.STATIC, 0, this.BASE_CLASS, "createTag", byte.class);
 
                 // Prepare CraftItemStack
-                CRAFT_STACK = loader.loadClass(packageName + ".inventory.CraftItemStack");
-                CRAFT_HANDLE = getField(null, CRAFT_STACK, "handle");
-                STACK_TAG = getField(null, CRAFT_HANDLE.getType(), "tag");
+                this.CRAFT_STACK = loader.loadClass(packageName + ".inventory.CraftItemStack");
+                this.CRAFT_HANDLE = getField(null, this.CRAFT_STACK, "handle");
+                this.STACK_TAG = getField(null, this.CRAFT_HANDLE.getType(), "tag");
 
                 // Loading/saving
-                final String nmsPackage = BASE_CLASS.getPackage().getName();
+                String nmsPackage = this.BASE_CLASS.getPackage().getName();
                 initializeNMS(loader, nmsPackage);
 
-                LOAD_COMPOUND = READ_LIMITER_CLASS != null ? new LoadMethodSkinUpdate(STREAM_TOOLS, READ_LIMITER_CLASS) :
-                        new LoadMethodWorldUpdate(STREAM_TOOLS);
-                SAVE_COMPOUND = getMethod(Modifier.STATIC, 0, STREAM_TOOLS, null, BASE_CLASS, DataOutput.class);
+                if (this.READ_LIMITER_CLASS != null) {
+                    this.LOAD_COMPOUND = new LoadMethodSkinUpdate(this.STREAM_TOOLS, this.READ_LIMITER_CLASS);
+                } else {
+                    this.LOAD_COMPOUND = new LoadMethodWorldUpdate(this.STREAM_TOOLS);
+                }
+                this.SAVE_COMPOUND = getMethod(Modifier.STATIC, 0, this.STREAM_TOOLS, null, this.BASE_CLASS, DataOutput.class);
 
-            } catch (final ClassNotFoundException e) {
+            } catch (ClassNotFoundException e) {
                 throw new IllegalStateException("Unable to find offline player.", e);
             }
         }
@@ -101,7 +122,7 @@ public class NbtFactory {
      * Construct a new NBT list of an unspecified type.
      * @return The NBT list.
      */
-    public static NbtList createList(final Object... content) {
+    public static NbtList createList(Object... content) {
         return createList(Arrays.asList(content));
     }
 
@@ -109,11 +130,11 @@ public class NbtFactory {
      * Construct a new NBT list of an unspecified type.
      * @return The NBT list.
      */
-    public static NbtList createList(final Iterable<? extends Object> iterable) {
-        final NbtList list = get().new NbtList(INSTANCE.createNbtTag(NbtType.TAG_LIST, null));
+    public static NbtList createList(Iterable<? extends Object> iterable) {
+        NbtList list = get().new NbtList(INSTANCE.createNbtTag(NbtType.TAG_LIST, null));
 
         // Add the content as well
-        for (final Object obj : iterable) {
+        for (Object obj : iterable) {
             list.add(obj);
         }
         return list;
@@ -121,7 +142,6 @@ public class NbtFactory {
 
     /**
      * Construct a new NBT compound.
-     * <p>
      *
      * @return The NBT compound.
      */
@@ -134,29 +154,33 @@ public class NbtFactory {
      * @param nmsList - the NBT list.
      * @return The wrapper.
      */
-    public static NbtList fromList(final Object nmsList) {
+    public static NbtList fromList(Object nmsList) {
         return get().new NbtList(nmsList);
     }
 
     /**
      * Load the content of a file from a stream.
-     * <p>
-     * Use {@link Files#newInputStreamSupplier(java.io.File)} to provide a stream from a file.
+     *
+     * Use {@link Files#newInputStreamSupplier(File)} to provide a stream from a file.
      * @param stream - the stream supplier.
      * @param option - whether or not to decompress the input stream.
      * @return The decoded NBT compound.
      * @throws IOException If anything went wrong.
      */
-    public static NbtCompound fromStream(final InputSupplier<? extends InputStream> stream, final StreamOptions option) throws IOException {
+    public static NbtCompound fromStream(ByteSource stream, StreamOptions option) throws IOException {
         InputStream input = null;
         DataInputStream data = null;
         boolean suppress = true;
 
         try {
-            input = stream.getInput();
-            data = new DataInputStream(new BufferedInputStream(option == StreamOptions.GZIP_COMPRESSION ? new GZIPInputStream(input) : input));
+            input = stream.openStream();
+            if (option == StreamOptions.GZIP_COMPRESSION) {
+                data = new DataInputStream(new BufferedInputStream(new GZIPInputStream(input)));
+            } else {
+                data = new DataInputStream(new BufferedInputStream(input));
+            }
 
-            final NbtCompound result = fromCompound(get().LOAD_COMPOUND.loadNbt(data));
+            NbtCompound result = fromCompound(get().LOAD_COMPOUND.loadNbt(data));
             suppress = false;
             return result;
 
@@ -171,14 +195,14 @@ public class NbtFactory {
 
     /**
      * Save the content of a NBT compound to a stream.
-     * <p>
-     * Use {@link Files#newOutputStreamSupplier(java.io.File)} to provide a stream supplier to a file.
+     *
+     * Use {@link Files#newOutputStreamSupplier(File)} to provide a stream supplier to a file.
      * @param source - the NBT compound to save.
      * @param stream - the stream.
      * @param option - whether or not to compress the output.
      * @throws IOException If anything went wrong.
      */
-    public static void saveStream(final NbtCompound source, final ByteSink stream, final StreamOptions option) throws IOException {
+    public static void saveStream(NbtCompound source, ByteSink stream, StreamOptions option) throws IOException {
         OutputStream output = null;
         DataOutputStream data = null;
         boolean suppress = true;
@@ -201,10 +225,10 @@ public class NbtFactory {
 
     /**
      * Construct a new NBT wrapper from a compound.
-     * @param nmsCompound - the NBT compund.
+     * @param nmsCompound - the NBT compound.
      * @return The wrapper.
      */
-    public static NbtCompound fromCompound(final Object nmsCompound) {
+    public static NbtCompound fromCompound(Object nmsCompound) {
         return get().new NbtCompound(nmsCompound);
     }
 
@@ -215,9 +239,9 @@ public class NbtFactory {
      * @param compound - the new NBT compound, or NULL to remove it.
      * @throws IllegalArgumentException If the stack is not a CraftItemStack, or it represents air.
      */
-    public static void setItemTag(final ItemStack stack, final NbtCompound compound) {
+    public static void setItemTag(ItemStack stack, NbtCompound compound) {
         checkItemStack(stack);
-        final Object nms = getFieldValue(get().CRAFT_HANDLE, stack);
+        Object nms = getFieldValue(get().CRAFT_HANDLE, stack);
 
         // Now update the tag compound
         setFieldValue(get().STACK_TAG, nms, compound.getHandle());
@@ -225,21 +249,21 @@ public class NbtFactory {
 
     /**
      * Construct a wrapper for an NBT tag stored (in memory) in an item stack. This is where
-     * auxillary data such as enchanting, name and lore is stored. It does not include items
+     * auxiliary data such as enchanting, name and lore is stored. It does not include items
      * material, damage value or count.
      * <p>
      * The item stack must be a wrapper for a CraftItemStack.
      * @param stack - the item stack.
      * @return A wrapper for its NBT tag.
      */
-    public static NbtCompound fromItemTag(final ItemStack stack) {
+    public static NbtCompound fromItemTag(ItemStack stack) {
         checkItemStack(stack);
-        final Object nms = getFieldValue(get().CRAFT_HANDLE, stack);
-        final Object tag = getFieldValue(get().STACK_TAG, nms);
+        Object nms = getFieldValue(get().CRAFT_HANDLE, stack);
+        Object tag = getFieldValue(get().STACK_TAG, nms);
 
         // Create the tag if it doesn't exist
         if (tag == null) {
-            final NbtCompound compound = createCompound();
+            NbtCompound compound = createCompound();
             setItemTag(stack, compound);
             return compound;
         }
@@ -251,17 +275,17 @@ public class NbtFactory {
      * @param stack - the stack to convert.
      * @return The CraftItemStack version.
      */
-    public static ItemStack getCraftItemStack(final ItemStack stack) {
+    public static ItemStack getCraftItemStack(ItemStack stack) {
         // Any need to convert?
         if ((stack == null) || get().CRAFT_STACK.isAssignableFrom(stack.getClass())) {
             return stack;
         }
         try {
             // Call the private constructor
-            final Constructor<?> caller = INSTANCE.CRAFT_STACK.getDeclaredConstructor(ItemStack.class);
+            Constructor<?> caller = INSTANCE.CRAFT_STACK.getDeclaredConstructor(ItemStack.class);
             caller.setAccessible(true);
             return (ItemStack) caller.newInstance(stack);
-        } catch (final Exception e) {
+        } catch (Exception ignored) {
             throw new IllegalStateException("Unable to convert " + stack + " + to a CraftItemStack.");
         }
     }
@@ -270,7 +294,7 @@ public class NbtFactory {
      * Ensure that the given stack can store arbitrary NBT information.
      * @param stack - the stack to check.
      */
-    private static void checkItemStack(final ItemStack stack) {
+    private static void checkItemStack(ItemStack stack) {
         if (stack == null) {
             throw new IllegalArgumentException("Stack cannot be NULL.");
         }
@@ -289,32 +313,32 @@ public class NbtFactory {
      * @param params - the parameters to supply.
      * @return The result of the method.
      */
-    private static Object invokeMethod(final Method method, final Object target, final Object... params) {
+    private static Object invokeMethod(Method method, Object target, Object... params) {
         try {
             return method.invoke(target, params);
-        } catch (final Exception e) {
+        } catch (IllegalAccessException | InvocationTargetException | IllegalArgumentException e) {
             throw new RuntimeException("Unable to invoke method " + method + " for " + target, e);
         }
     }
 
-    private static void setFieldValue(final Field field, final Object target, final Object value) {
+    private static void setFieldValue(Field field, Object target, Object value) {
         try {
             field.set(target, value);
-        } catch (final Exception e) {
+        } catch (IllegalAccessException | IllegalArgumentException e) {
             throw new RuntimeException("Unable to set " + field + " for " + target, e);
         }
     }
 
-    private static Object getFieldValue(final Field field, final Object target) {
+    private static Object getFieldValue(Field field, Object target) {
         try {
             return field.get(target);
-        } catch (final Exception e) {
+        } catch (IllegalAccessException | IllegalArgumentException e) {
             throw new RuntimeException("Unable to retrieve " + field + " for " + target, e);
         }
     }
 
     /**
-     * Search for the first publically and privately defined method of the given name and parameter count.
+     * Search for the first publicly and privately defined method of the given name and parameter count.
      * @param requireMod - modifiers that are required.
      * @param bannedMod - modifiers that are banned.
      * @param clazz - a class to start with.
@@ -323,9 +347,9 @@ public class NbtFactory {
      * @return The first method by this name.
      * @throws IllegalStateException If we cannot find this method.
      */
-    private static Method getMethod(final int requireMod, final int bannedMod, final Class<?> clazz, final String methodName,
-            final Class<?>... params) {
-        for (final Method method : clazz.getDeclaredMethods()) {
+    private static Method getMethod(int requireMod, int bannedMod, Class<?> clazz, String methodName,
+            Class<?>... params) {
+        for (Method method : clazz.getDeclaredMethods()) {
             // Limitation: Doesn't handle overloads
             if (((method.getModifiers() & requireMod) == requireMod)
                     && ((method.getModifiers() & bannedMod) == 0)
@@ -344,19 +368,19 @@ public class NbtFactory {
     }
 
     /**
-     * Search for the first publically and privately defined field of the given name.
+     * Search for the first publicly and privately defined field of the given name.
      * @param instance - an instance of the class with the field.
      * @param clazz - an optional class to start with, or NULL to deduce it from instance.
      * @param fieldName - the field name.
      * @return The first field by this name.
      * @throws IllegalStateException If we cannot find this field.
      */
-    private static Field getField(final Object instance, Class<?> clazz, final String fieldName) {
+    private static Field getField(Object instance, Class<?> clazz, String fieldName) {
         if (clazz == null) {
             clazz = instance.getClass();
         }
         // Ignore access rules
-        for (final Field field : clazz.getDeclaredFields()) {
+        for (Field field : clazz.getDeclaredFields()) {
             if (field.getName().equals(fieldName)) {
                 field.setAccessible(true);
                 return field;
@@ -369,18 +393,16 @@ public class NbtFactory {
         throw new IllegalStateException("Unable to find field " + fieldName + " in " + instance);
     }
 
-    private void initializeNMS(final ClassLoader loader, final String nmsPackage) {
+    private void initializeNMS(ClassLoader loader, String nmsPackage) {
         try {
-            STREAM_TOOLS = loader.loadClass(nmsPackage + ".NBTCompressedStreamTools");
-            READ_LIMITER_CLASS = loader.loadClass(nmsPackage + ".NBTReadLimiter");
-        } catch (final ClassNotFoundException e) {
-            // Ignore - we will detect this later
-        }
+            this.STREAM_TOOLS = loader.loadClass(nmsPackage + ".NBTCompressedStreamTools");
+            this.READ_LIMITER_CLASS = loader.loadClass(nmsPackage + ".NBTReadLimiter");
+        } catch (ClassNotFoundException ignored) {}
     }
 
     private String getPackageName() {
-        final Server server = Bukkit.getServer();
-        final String name = server != null ? server.getClass().getPackage().getName() : null;
+        Server server = Bukkit.getServer();
+        String name = server != null ? server.getClass().getPackage().getName() : null;
 
         if ((name != null) && name.contains("craftbukkit")) {
             return name;
@@ -391,12 +413,12 @@ public class NbtFactory {
     }
 
     @SuppressWarnings("unchecked")
-    private Map<String, Object> getDataMap(final Object handle) {
+    private Map<String, Object> getDataMap(Object handle) {
         return (Map<String, Object>) getFieldValue(getDataField(NbtType.TAG_COMPOUND, handle), handle);
     }
 
     @SuppressWarnings("unchecked")
-    private List<Object> getDataList(final Object handle) {
+    private List<Object> getDataList(Object handle) {
         return (List<Object>) getFieldValue(getDataField(NbtType.TAG_LIST, handle), handle);
     }
 
@@ -405,19 +427,17 @@ public class NbtFactory {
      * @param value - the value of the element to create. Can be a List or a Map.
      * @return The NBT element.
      */
-    private Object unwrapValue(final Object value) {
+    private Object unwrapValue(Object value) {
         if (value == null) {
             return null;
         }
 
         if (value instanceof Wrapper) {
             return ((Wrapper) value).getHandle();
-
         } else if (value instanceof List) {
             throw new IllegalArgumentException("Can only insert a WrappedList.");
         } else if (value instanceof Map) {
             throw new IllegalArgumentException("Can only insert a WrappedCompound.");
-
         } else {
             return createNbtTag(getPrimitiveType(value), value);
         }
@@ -430,13 +450,13 @@ public class NbtFactory {
      * @param nms - the NBT element.
      * @return The wrapper equivalent.
      */
-    private Object wrapNative(final Object nms) {
+    private Object wrapNative(Object nms) {
         if (nms == null) {
             return null;
         }
 
-        if (BASE_CLASS.isAssignableFrom(nms.getClass())) {
-            final NbtType type = getNbtType(nms);
+        if (this.BASE_CLASS.isAssignableFrom(nms.getClass())) {
+            NbtType type = getNbtType(nms);
 
             // Handle the different types
             switch (type) {
@@ -457,8 +477,8 @@ public class NbtFactory {
      * @param value - the value, or NULL to keep the original value.
      * @return The created tag.
      */
-    private Object createNbtTag(final NbtType type, final Object value) {
-        final Object tag = invokeMethod(NBT_CREATE_TAG, null, (byte) type.id);
+    private Object createNbtTag(NbtType type, Object value) {
+        Object tag = invokeMethod(this.NBT_CREATE_TAG, null, (byte) type.id);
 
         if (value != null) {
             setFieldValue(getDataField(type, tag), tag, value);
@@ -472,11 +492,11 @@ public class NbtFactory {
      * @param nms - the NBT class instance.
      * @return The corresponding field.
      */
-    private Field getDataField(final NbtType type, final Object nms) {
-        if (DATA_FIELD[type.id] == null) {
-            DATA_FIELD[type.id] = getField(nms, null, type.getFieldName());
+    private Field getDataField(NbtType type, Object nms) {
+        if (this.DATA_FIELD[type.id] == null) {
+            this.DATA_FIELD[type.id] = getField(nms, null, type.getFieldName());
         }
-        return DATA_FIELD[type.id];
+        return this.DATA_FIELD[type.id];
     }
 
     /**
@@ -484,8 +504,8 @@ public class NbtFactory {
      * @param nms - the native NBT tag.
      * @return The corresponding type.
      */
-    private NbtType getNbtType(final Object nms) {
-        final int type = (Byte) invokeMethod(NBT_GET_TYPE, nms);
+    private NbtType getNbtType(Object nms) {
+        int type = (Byte) invokeMethod(this.NBT_GET_TYPE, nms);
         return NBT_ENUM.get(type);
     }
 
@@ -494,8 +514,8 @@ public class NbtFactory {
      * @param primitive - the primitive type.
      * @return The corresponding type.
      */
-    private NbtType getPrimitiveType(final Object primitive) {
-        final NbtType type = NBT_ENUM.get(NBT_CLASS.inverse().get(Primitives.unwrap(primitive.getClass())));
+    private NbtType getPrimitiveType(Object primitive) {
+        NbtType type = NBT_ENUM.get(NBT_CLASS.inverse().get(Primitives.unwrap(primitive.getClass())));
 
         // Display the illegal value at least
         if (type == null) {
@@ -529,7 +549,7 @@ public class NbtFactory {
         // Unique NBT type
         public final int id;
 
-        NbtType(final int id, final Class<?> type) {
+        NbtType(int id, Class<?> type) {
             this.id = id;
             NBT_CLASS.put(id, type);
             NBT_ENUM.put(id, this);
@@ -567,9 +587,9 @@ public class NbtFactory {
 
         protected Method staticMethod;
 
-        protected void setMethod(final Method method) {
-            staticMethod = method;
-            staticMethod.setAccessible(true);
+        protected void setMethod(Method method) {
+            this.staticMethod = method;
+            this.staticMethod.setAccessible(true);
         }
 
         /**
@@ -577,7 +597,7 @@ public class NbtFactory {
          * @param input - the input stream.
          * @return The loaded NBT compound.
          */
-        public abstract Object loadNbt(final DataInput input);
+        public abstract Object loadNbt(DataInput input);
     }
 
     /**
@@ -585,13 +605,13 @@ public class NbtFactory {
      */
     private static class LoadMethodWorldUpdate extends LoadCompoundMethod {
 
-        public LoadMethodWorldUpdate(final Class<?> streamClass) {
+        public LoadMethodWorldUpdate(Class<?> streamClass) {
             setMethod(getMethod(Modifier.STATIC, 0, streamClass, null, DataInput.class));
         }
 
         @Override
-        public Object loadNbt(final DataInput input) {
-            return invokeMethod(staticMethod, null, input);
+        public Object loadNbt(DataInput input) {
+            return invokeMethod(this.staticMethod, null, input);
         }
     }
 
@@ -602,15 +622,15 @@ public class NbtFactory {
 
         private Object readLimiter;
 
-        public LoadMethodSkinUpdate(final Class<?> streamClass, final Class<?> readLimiterClass) {
+        public LoadMethodSkinUpdate(Class<?> streamClass, Class<?> readLimiterClass) {
             setMethod(getMethod(Modifier.STATIC, 0, streamClass, null, DataInput.class, readLimiterClass));
 
             // Find the unlimited read limiter
-            for (final Field field : readLimiterClass.getDeclaredFields()) {
+            for (Field field : readLimiterClass.getDeclaredFields()) {
                 if (readLimiterClass.isAssignableFrom(field.getType())) {
                     try {
-                        readLimiter = field.get(null);
-                    } catch (final Exception e) {
+                        this.readLimiter = field.get(null);
+                    } catch (Exception e) {
                         throw new RuntimeException("Cannot retrieve read limiter.", e);
                     }
                 }
@@ -618,8 +638,8 @@ public class NbtFactory {
         }
 
         @Override
-        public Object loadNbt(final DataInput input) {
-            return invokeMethod(staticMethod, null, input, readLimiter);
+        public Object loadNbt(DataInput input) {
+            return invokeMethod(this.staticMethod, null, input, this.readLimiter);
         }
     }
 
@@ -629,7 +649,7 @@ public class NbtFactory {
      * All changes to this map will be reflected in the underlying NBT compound. Values may only be one of the following:
      * <ul>
      *   <li>Primitive types</li>
-     *   <li>{@link java.lang.String String}</li>
+     *   <li>{@link String String}</li>
      *   <li>{@link NbtList}</li>
      *   <li>{@link NbtCompound}</li>
      * </ul>
@@ -643,44 +663,44 @@ public class NbtFactory {
      */
     public final class NbtCompound extends ConvertedMap {
 
-        private NbtCompound(final Object handle) {
+        private NbtCompound(Object handle) {
             super(handle, getDataMap(handle));
         }
 
-        // Simplifiying access to each value
-        public Byte getByte(final String key, final Byte defaultValue) {
+        // Simplifying access to each value
+        public Byte getByte(String key, Byte defaultValue) {
             return containsKey(key) ? (Byte) get(key) : defaultValue;
         }
 
-        public Short getShort(final String key, final Short defaultValue) {
+        public Short getShort(String key, Short defaultValue) {
             return containsKey(key) ? (Short) get(key) : defaultValue;
         }
 
-        public Integer getInteger(final String key, final Integer defaultValue) {
+        public Integer getInteger(String key, Integer defaultValue) {
             return containsKey(key) ? (Integer) get(key) : defaultValue;
         }
 
-        public Long getLong(final String key, final Long defaultValue) {
+        public Long getLong(String key, Long defaultValue) {
             return containsKey(key) ? (Long) get(key) : defaultValue;
         }
 
-        public Float getFloat(final String key, final Float defaultValue) {
+        public Float getFloat(String key, Float defaultValue) {
             return containsKey(key) ? (Float) get(key) : defaultValue;
         }
 
-        public Double getDouble(final String key, final Double defaultValue) {
+        public Double getDouble(String key, Double defaultValue) {
             return containsKey(key) ? (Double) get(key) : defaultValue;
         }
 
-        public String getString(final String key, final String defaultValue) {
+        public String getString(String key, String defaultValue) {
             return containsKey(key) ? (String) get(key) : defaultValue;
         }
 
-        public byte[] getByteArray(final String key, final byte[] defaultValue) {
+        public byte[] getByteArray(String key, byte[] defaultValue) {
             return containsKey(key) ? (byte[]) get(key) : defaultValue;
         }
 
-        public int[] getIntegerArray(final String key, final int[] defaultValue) {
+        public int[] getIntegerArray(String key, int[] defaultValue) {
             return containsKey(key) ? (int[]) get(key) : defaultValue;
         }
 
@@ -690,7 +710,7 @@ public class NbtFactory {
          * @param createNew - whether or not to create a new list if its missing.
          * @return An existing list, a new list or NULL.
          */
-        public NbtList getList(final String key, final boolean createNew) {
+        public NbtList getList(String key, boolean createNew) {
             NbtList list = (NbtList) get(key);
 
             if ((list == null) && createNew) {
@@ -705,7 +725,7 @@ public class NbtFactory {
          * @param createNew - whether or not to create a new map if its missing.
          * @return An existing map, a new map or NULL.
          */
-        public NbtCompound getMap(final String key, final boolean createNew) {
+        public NbtCompound getMap(String key, boolean createNew) {
             return getMap(Collections.singletonList(key), createNew);
         }
 
@@ -720,9 +740,9 @@ public class NbtFactory {
          * @param value - the new value of this entry.
          * @return This compound, for chaining.
          */
-        public NbtCompound putPath(final String path, final Object value) {
-            final List<String> entries = getPathElements(path);
-            final Map<String, Object> map = getMap(entries.subList(0, entries.size() - 1), true);
+        public NbtCompound putPath(String path, Object value) {
+            List<String> entries = getPathElements(path);
+            Map<String, Object> map = getMap(entries.subList(0, entries.size() - 1), true);
 
             map.put(entries.get(entries.size() - 1), value);
             return this;
@@ -737,9 +757,9 @@ public class NbtFactory {
          * @return The value, or NULL if not found.
          */
         @SuppressWarnings("unchecked")
-        public <T> T getPath(final String path) {
-            final List<String> entries = getPathElements(path);
-            final NbtCompound map = getMap(entries.subList(0, entries.size() - 1), false);
+        public <T> T getPath(String path) {
+            List<String> entries = getPathElements(path);
+            NbtCompound map = getMap(entries.subList(0, entries.size() - 1), false);
 
             if (map != null) {
                 return (T) map.get(entries.get(entries.size() - 1));
@@ -750,12 +770,12 @@ public class NbtFactory {
         /**
          * Save the content of a NBT compound to a stream.
          * <p>
-         * Use {@link Files#newOutputStreamSupplier(java.io.File)} to provide a stream supplier to a file.
+         * Use {@link Files#newOutputStreamSupplier(File)} to provide a stream supplier to a file.
          * @param stream - the output stream.
          * @param option - whether or not to compress the output.
          * @throws IOException If anything went wrong.
          */
-        public void saveTo(final ByteSink stream, final StreamOptions option) throws IOException {
+        public void saveTo(ByteSink stream, StreamOptions option) throws IOException {
             saveStream(this, stream, option);
         }
 
@@ -765,10 +785,10 @@ public class NbtFactory {
          * @param createNew - whether or not to create new compounds on the way.
          * @return The map at this location.
          */
-        private NbtCompound getMap(final Iterable<String> path, final boolean createNew) {
+        private NbtCompound getMap(Iterable<String> path, boolean createNew) {
             NbtCompound current = this;
 
-            for (final String entry : path) {
+            for (String entry : path) {
                 NbtCompound child = (NbtCompound) current.get(entry);
 
                 if (child == null) {
@@ -787,7 +807,7 @@ public class NbtFactory {
          * @param path - the path to split.
          * @return The elements.
          */
-        private List<String> getPathElements(final String path) {
+        private List<String> getPathElements(String path) {
             return Lists.newArrayList(Splitter.on(".").omitEmptyStrings().split(path));
         }
     }
@@ -803,7 +823,7 @@ public class NbtFactory {
      */
     public final class NbtList extends ConvertedList {
 
-        private NbtList(final Object handle) {
+        private NbtList(Object handle) {
             super(handle, getDataList(handle));
         }
     }
@@ -817,15 +837,15 @@ public class NbtFactory {
         // Don't recreate wrapper objects
         private final ConcurrentMap<Object, Object> cache = new MapMaker().weakKeys().makeMap();
 
-        public Object wrap(final Object value) {
-            Object current = cache.get(value);
+        public Object wrap(Object value) {
+            Object current = this.cache.get(value);
 
             if (current == null) {
                 current = wrapNative(value);
 
                 // Only cache composite objects
                 if ((current instanceof ConvertedMap) || (current instanceof ConvertedList)) {
-                    cache.put(value, current);
+                    this.cache.put(value, current);
                 }
             }
             return current;
@@ -844,57 +864,57 @@ public class NbtFactory {
 
         private final CachedNativeWrapper cache = new CachedNativeWrapper();
 
-        public ConvertedMap(final Object handle, final Map<String, Object> original) {
+        public ConvertedMap(Object handle, Map<String, Object> original) {
             this.handle = handle;
             this.original = original;
         }
 
         // For converting back and forth
-        protected Object wrapOutgoing(final Object value) {
-            return cache.wrap(value);
+        protected Object wrapOutgoing(Object value) {
+            return this.cache.wrap(value);
         }
 
-        protected Object unwrapIncoming(final Object wrapped) {
+        protected Object unwrapIncoming(Object wrapped) {
             return unwrapValue(wrapped);
         }
 
         // Modification
         @Override
-        public Object put(final String key, final Object value) {
-            return wrapOutgoing(original.put(key, unwrapIncoming(value)));
+        public Object put(String key, Object value) {
+            return wrapOutgoing(this.original.put(key, unwrapIncoming(value)));
         }
 
         // Performance
         @Override
-        public Object get(final Object key) {
-            return wrapOutgoing(original.get(key));
+        public Object get(Object key) {
+            return wrapOutgoing(this.original.get(key));
         }
 
         @Override
-        public Object remove(final Object key) {
-            return wrapOutgoing(original.remove(key));
+        public Object remove(Object key) {
+            return wrapOutgoing(this.original.remove(key));
         }
 
         @Override
-        public boolean containsKey(final Object key) {
-            return original.containsKey(key);
+        public boolean containsKey(Object key) {
+            return this.original.containsKey(key);
         }
 
         @Override
         public Set<Entry<String, Object>> entrySet() {
             return new AbstractSet<Entry<String, Object>>() {
                 @Override
-                public boolean add(final Entry<String, Object> e) {
-                    final String key = e.getKey();
-                    final Object value = e.getValue();
+                public boolean add(Entry<String, Object> e) {
+                    String key = e.getKey();
+                    Object value = e.getValue();
 
-                    original.put(key, unwrapIncoming(value));
+                    ConvertedMap.this.original.put(key, unwrapIncoming(value));
                     return true;
                 }
 
                 @Override
                 public int size() {
-                    return original.size();
+                    return ConvertedMap.this.original.size();
                 }
 
                 @Override
@@ -905,7 +925,7 @@ public class NbtFactory {
         }
 
         private Iterator<Entry<String, Object>> iterator() {
-            final Iterator<Entry<String, Object>> proxy = original.entrySet().iterator();
+            final Iterator<Entry<String, Object>> proxy = this.original.entrySet().iterator();
 
             return new Iterator<Entry<String, Object>>() {
                 @Override
@@ -915,7 +935,7 @@ public class NbtFactory {
 
                 @Override
                 public Entry<String, Object> next() {
-                    final Entry<String, Object> entry = proxy.next();
+                    Entry<String, Object> entry = proxy.next();
 
                     return new SimpleEntry<String, Object>(entry.getKey(), wrapOutgoing(entry.getValue()));
                 }
@@ -929,7 +949,7 @@ public class NbtFactory {
 
         @Override
         public Object getHandle() {
-            return handle;
+            return this.handle;
         }
     }
 
@@ -945,61 +965,61 @@ public class NbtFactory {
         private final List<Object> original;
         private final CachedNativeWrapper cache = new CachedNativeWrapper();
 
-        public ConvertedList(final Object handle, final List<Object> original) {
-            if (NBT_LIST_TYPE == null) {
-                NBT_LIST_TYPE = getField(handle, null, "type");
+        public ConvertedList(Object handle, List<Object> original) {
+            if (NbtFactory.this.NBT_LIST_TYPE == null) {
+                NbtFactory.this.NBT_LIST_TYPE = getField(handle, null, "type");
             }
             this.handle = handle;
             this.original = original;
         }
 
-        protected Object wrapOutgoing(final Object value) {
-            return cache.wrap(value);
+        protected Object wrapOutgoing(Object value) {
+            return this.cache.wrap(value);
         }
 
-        protected Object unwrapIncoming(final Object wrapped) {
+        protected Object unwrapIncoming(Object wrapped) {
             return unwrapValue(wrapped);
         }
 
         @Override
-        public Object get(final int index) {
-            return wrapOutgoing(original.get(index));
+        public Object get(int index) {
+            return wrapOutgoing(this.original.get(index));
         }
 
         @Override
         public int size() {
-            return original.size();
+            return this.original.size();
         }
 
         @Override
-        public Object set(final int index, final Object element) {
-            return wrapOutgoing(original.set(index, unwrapIncoming(element)));
+        public Object set(int index, Object element) {
+            return wrapOutgoing(this.original.set(index, unwrapIncoming(element)));
         }
 
         @Override
-        public void add(final int index, final Object element) {
-            final Object nbt = unwrapIncoming(element);
+        public void add(int index, Object element) {
+            Object nbt = unwrapIncoming(element);
 
             // Set the list type if its the first element
             if (size() == 0) {
-                setFieldValue(NBT_LIST_TYPE, handle, (byte) getNbtType(nbt).id);
+                setFieldValue(NbtFactory.this.NBT_LIST_TYPE, this.handle, (byte) getNbtType(nbt).id);
             }
-            original.add(index, nbt);
+            this.original.add(index, nbt);
         }
 
         @Override
-        public Object remove(final int index) {
-            return wrapOutgoing(original.remove(index));
+        public Object remove(int index) {
+            return wrapOutgoing(this.original.remove(index));
         }
 
         @Override
-        public boolean remove(final Object o) {
-            return original.remove(unwrapIncoming(o));
+        public boolean remove(Object o) {
+            return this.original.remove(unwrapIncoming(o));
         }
 
         @Override
         public Object getHandle() {
-            return handle;
+            return this.handle;
         }
     }
 }

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

@@ -19,15 +19,15 @@ 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"),
+    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"));
-        final Object entityPlayer = callConstructor(entityPlayerConstructor, server, worldServer, profile, interactManager);
+        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 = makeConstructor(gameProfileClass, UUID.class, String.class);
-        if (gameProfileConstructor == null) { //Verson has string constructor
+        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

@@ -1,5 +1,7 @@
 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;
@@ -17,11 +19,12 @@ import org.bukkit.Chunk;
 import org.bukkit.World;
 import org.bukkit.entity.Player;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map.Entry;
 
-import static com.intellectualcrafters.plot.util.ReflectionUtils.getRefClass;
-
 /**
  * An utility that can be used to send chunks, rather than using bukkit code to do so (uses heavy NMS)
  *
@@ -29,17 +32,9 @@ import static com.intellectualcrafters.plot.util.ReflectionUtils.getRefClass;
  */
 public class SendChunk {
 
-    //    // Ref Class
-    private final RefClass classEntityPlayer = getRefClass("{nms}.EntityPlayer");
-    private final RefClass classMapChunk = getRefClass("{nms}.PacketPlayOutMapChunk");
-    private final RefClass classPacket = getRefClass("{nms}.Packet");
-    private final RefClass classConnection = getRefClass("{nms}.PlayerConnection");
-    private final RefClass classChunk = getRefClass("{nms}.Chunk");
-    private final RefClass classCraftPlayer = getRefClass("{cb}.entity.CraftPlayer");
-    private final RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
     private final RefMethod methodGetHandlePlayer;
     private final RefMethod methodGetHandleChunk;
-    private final RefConstructor MapChunk;
+    private final RefConstructor mapChunk;
     private final RefField connection;
     private final RefMethod send;
     private final RefMethod methodInitLighting;
@@ -47,64 +42,100 @@ public class SendChunk {
     /**
      * Constructor
      */
-    public SendChunk() {
-        methodGetHandlePlayer = classCraftPlayer.getMethod("getHandle");
-        methodGetHandleChunk = classCraftChunk.getMethod("getHandle");
-        methodInitLighting = classChunk.getMethod("initLighting");
-        MapChunk = classMapChunk.getConstructor(classChunk.getRealClass(), boolean.class, int.class);
-        connection = classEntityPlayer.getField("playerConnection");
-        send = classConnection.getMethod("sendPacket", classPacket.getRealClass());
+    public SendChunk() throws ClassNotFoundException, NoSuchMethodException, NoSuchFieldException {
+        RefConstructor tempMapChunk;
+        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");
+        if (PS.get().checkVersion(PS.get().IMP.getServerVersion(), 1, 9, 4)) {
+            //this works for 1.9.4 and 1.10
+            tempMapChunk = classMapChunk.getConstructor(classChunk.getRealClass(),int.class);
+        } else {
+            try {
+                tempMapChunk = classMapChunk.getConstructor(classChunk.getRealClass(), boolean.class, int.class);
+            } catch (NoSuchMethodException ignored) {
+                tempMapChunk = classMapChunk.getConstructor(classChunk.getRealClass(),boolean.class, int.class, int.class);
+            }
+        }
+        this.mapChunk = tempMapChunk;
+        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(final Collection<Chunk> input) {
-        final HashSet<Chunk> chunks = new HashSet<Chunk>(input);
-        final HashMap<String, ArrayList<Chunk>> map = new HashMap<>();
-        final int view = Bukkit.getServer().getViewDistance();
-        for (final Chunk chunk : chunks) {
-            final String world = chunk.getWorld().getName();
+    public void sendChunk(Collection<Chunk> input) {
+        HashSet<Chunk> chunks = new HashSet<>(input);
+        HashMap<String, ArrayList<Chunk>> map = new HashMap<>();
+        int view = Bukkit.getServer().getViewDistance();
+        for (Chunk chunk : chunks) {
+            String world = chunk.getWorld().getName();
             ArrayList<Chunk> list = map.get(world);
             if (list == null) {
                 list = new ArrayList<>();
                 map.put(world, list);
             }
             list.add(chunk);
-            final Object c = methodGetHandleChunk.of(chunk).call();
-            methodInitLighting.of(c).call();
+            Object c = this.methodGetHandleChunk.of(chunk).call();
+            this.methodInitLighting.of(c).call();
         }
         for (Entry<String, PlotPlayer> entry : UUIDHandler.getPlayers().entrySet()) {
             PlotPlayer pp = entry.getValue();
-            final Plot plot = pp.getCurrentPlot();
-            Location loc = null;
+            Plot plot = pp.getCurrentPlot();
+            Location location = null;
             String world;
             if (plot != null) {
                 world = plot.getArea().worldname;
             } else {
-                loc = pp.getLocation();
-                world = loc.getWorld();
+                location = pp.getLocation();
+                world = location.getWorld();
             }
-            final ArrayList<Chunk> list = map.get(world);
+            ArrayList<Chunk> list = map.get(world);
             if (list == null) {
                 continue;
             }
-            if (loc == null) {
-                loc = pp.getLocation();
+            if (location == null) {
+                location = pp.getLocation();
             }
-            final int cx = loc.getX() >> 4;
-            final int cz = loc.getZ() >> 4;
-            final Player player = ((BukkitPlayer) pp).player;
-            final Object entity = methodGetHandlePlayer.of(player).call();
+            int cx = location.getX() >> 4;
+            int cz = location.getZ() >> 4;
+            Player player = ((BukkitPlayer) pp).player;
+            Object entity = this.methodGetHandlePlayer.of(player).call();
 
-            for (final Chunk chunk : list) {
-                final int dx = Math.abs(cx - chunk.getX());
-                final int dz = Math.abs(cz - chunk.getZ());
+            for (Chunk chunk : list) {
+                int dx = Math.abs(cx - chunk.getX());
+                int dz = Math.abs(cz - chunk.getZ());
                 if ((dx > view) || (dz > view)) {
                     continue;
                 }
-                final Object c = methodGetHandleChunk.of(chunk).call();
+                Object c = this.methodGetHandleChunk.of(chunk).call();
                 chunks.remove(chunk);
-                final Object con = connection.of(entity).get();
-                final Object packet = MapChunk.create(c, true, 65535);
-                send.of(con).call(packet);
+                Object con = this.connection.of(entity).get();
+                Object packet = null;
+                if (PS.get().checkVersion(PS.get().IMP.getServerVersion(), 1, 9, 4)) {
+                    try {
+                        packet = this.mapChunk.create(c,65535);
+                    } catch (Exception ignored) {}
+                } else {
+                    try {
+                        packet = this.mapChunk.create(c, true, 65535);
+                    } catch (ReflectiveOperationException | IllegalArgumentException e) {
+                        try {
+                            packet = this.mapChunk.create(c, true, 65535, 5);
+                        } catch (ReflectiveOperationException | IllegalArgumentException e1) {
+                            e1.printStackTrace();
+                        }
+                    }
+                }
+                if (packet == null) {
+                    PS.debug("Error with PacketPlayOutMapChunk reflection.");
+                }
+                this.send.of(con).call(packet);
             }
         }
         for (final Chunk chunk : chunks) {
@@ -113,11 +144,11 @@ public class SendChunk {
                 public void run() {
                     try {
                         chunk.unload(true, false);
-                    } catch (final Throwable e) {
-                        final String worldname = chunk.getWorld().getName();
-                        PS.debug("$4Could not save chunk: " + worldname + ";" + chunk.getX() + ";" + chunk.getZ());
+                    } catch (Throwable ignored) {
+                        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
+                        PS.debug("$3 - $4" + worldName + "/level.dat or " + worldName
                                 + "/level_old.dat may be corrupt (try repairing or removing these)");
                     }
                 }
@@ -125,12 +156,12 @@ public class SendChunk {
         }
     }
 
-    public void sendChunk(final String worldname, final List<ChunkLoc> locs) {
-        final World myworld = Bukkit.getWorld(worldname);
-        final ArrayList<Chunk> chunks = new ArrayList<>();
-        for (final ChunkLoc loc : locs) {
-            if (myworld.isChunkLoaded(loc.x, loc.z)) {
-                chunks.add(myworld.getChunkAt(loc.x, loc.z));
+    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

@@ -14,24 +14,24 @@ import java.util.Iterator;
 
 public class SetGenCB {
 
-    public static void setGenerator(final World world) throws Exception {
+    public static void setGenerator(World world) throws Exception {
         SetupUtils.manager.updateGenerators();
         PS.get().removePlotAreas(world.getName());
-        final ChunkGenerator gen = world.getGenerator();
+        ChunkGenerator gen = world.getGenerator();
         if (gen == null) {
             return;
         }
-        final String name = gen.getClass().getCanonicalName();
+        String name = gen.getClass().getCanonicalName();
         boolean set = false;
-        for (final GeneratorWrapper<?> wrapper : SetupUtils.generators.values()) {
+        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
-                final Field generator = world.getClass().getDeclaredField("generator");
-                final Field populators = world.getClass().getDeclaredField("populators");
+                Field generator = world.getClass().getDeclaredField("generator");
+                Field populators = world.getClass().getDeclaredField("populators");
                 generator.setAccessible(true);
                 populators.setAccessible(true);
                 // Set populators (just in case)
@@ -45,10 +45,10 @@ public class SetGenCB {
             }
         }
         if (!set) {
-            final Iterator<BlockPopulator> iter = world.getPopulators().iterator();
-            while (iter.hasNext()) {
-                if (iter.next() instanceof BukkitAugmentedGenerator) {
-                    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/BukkitLocalQueue.java

@@ -0,0 +1,127 @@
+package com.plotsquared.bukkit.util.block;
+
+import com.intellectualcrafters.plot.object.PlotBlock;
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.StringMan;
+import com.intellectualcrafters.plot.util.block.BasicLocalBlockQueue;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.block.Block;
+
+public class BukkitLocalQueue<T> extends BasicLocalBlockQueue<T> {
+
+    public BukkitLocalQueue(String world) {
+        super(world);
+    }
+
+    @Override
+    public LocalChunk<T> getLocalChunk(int x, int z) {
+        return (LocalChunk<T>) new BasicLocalChunk(this, x, z) {
+            // Custom stuff?
+        };
+    }
+
+    @Override
+    public void optimize() {
+
+    }
+
+    @Override
+    public PlotBlock getBlock(int x, int y, int z) {
+        World worldObj = Bukkit.getWorld(getWorld());
+        Block block = worldObj.getBlockAt(x, y, z);
+        if (block == null) {
+            return PlotBlock.get(0, 0);
+        }
+        int id = block.getTypeId();
+        if (id == 0) {
+            return PlotBlock.get(0, 0);
+        }
+        return PlotBlock.get(id, block.getData());
+    }
+
+    @Override
+    public void refreshChunk(int x, int z) {
+        World worldObj = Bukkit.getWorld(getWorld());
+        worldObj.refreshChunk(x, z);
+    }
+
+    @Override
+    public void fixChunkLighting(int x, int z) {
+        // Do nothing
+    }
+
+    @Override
+    public final void regenChunk(int x, int z) {
+        World worldObj = Bukkit.getWorld(getWorld());
+        worldObj.regenerateChunk(x, z);
+    }
+
+    @Override
+    public final void setComponents(LocalChunk<T> lc) {
+        setBlocks(lc);
+        setBiomes(lc);
+    }
+
+    public World getBukkitWorld() {
+        return Bukkit.getWorld(getWorld());
+    }
+
+    public Chunk getChunk(int x, int z) {
+        return getBukkitWorld().getChunkAt(x, z);
+    }
+
+    public void setBlocks(LocalChunk<T> lc) {
+        World worldObj = Bukkit.getWorld(getWorld());
+        Chunk chunk = worldObj.getChunkAt(lc.getX(), lc.getZ());
+        chunk.load(true);
+        for (int layer = 0; layer < lc.blocks.length; layer++) {
+            PlotBlock[] blocksLayer = (PlotBlock[]) lc.blocks[layer];
+            if (blocksLayer != null) {
+                for (int j = 0; j < blocksLayer.length; j++) {
+                    PlotBlock block = blocksLayer[j];
+                    int x = MainUtil.x_loc[layer][j];
+                    int y = MainUtil.y_loc[layer][j];
+                    int z = MainUtil.y_loc[layer][j];
+                    Block existing = chunk.getBlock(x, y, z);
+                    int existingId = existing.getTypeId();
+                    if (existingId == block.id) {
+                        if (existingId == 0) {
+                            continue;
+                        }
+                        if (existing.getData() == block.data) {
+                            continue;
+                        }
+                    }
+                    existing.setTypeIdAndData(block.id, block.data, false);
+                }
+            }
+        }
+    }
+
+    public void setBiomes(LocalChunk<T> lc) {
+        if (lc.biomes != null) {
+            World worldObj = Bukkit.getWorld(getWorld());
+            int bx = lc.getX() << 4;
+            int bz = lc.getX() << 4;
+            String last = null;
+            Biome biome = null;
+            for (int x = 0; x < lc.biomes.length; x++) {
+                String[] biomes2 = lc.biomes[x];
+                if (biomes2 != null) {
+                    for (int y = 0; y < biomes2.length; y++) {
+                        String biomeStr = biomes2[y];
+                        if (biomeStr != null) {
+                            if (last == null || !StringMan.isEqual(last, biomeStr)) {
+                                biome = Biome.valueOf(biomeStr.toUpperCase());
+                            }
+                            worldObj.setBiome(bx, bz, biome);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,130 @@
+package com.plotsquared.bukkit.util.block;
+
+import com.intellectualcrafters.plot.object.ChunkWrapper;
+import com.intellectualcrafters.plot.object.PlotBlock;
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.ReflectionUtils;
+import com.intellectualcrafters.plot.util.TaskManager;
+import com.plotsquared.bukkit.util.SendChunk;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+
+
+import static com.intellectualcrafters.plot.util.ReflectionUtils.getRefClass;
+
+public class BukkitLocalQueue_1_7 extends BukkitLocalQueue<PlotBlock[]> {
+
+    private final ReflectionUtils.RefClass classBlock = getRefClass("{nms}.Block");
+    private final ReflectionUtils.RefClass classChunk = getRefClass("{nms}.Chunk");
+    private final ReflectionUtils.RefClass classWorld = getRefClass("{nms}.World");
+    private final ReflectionUtils.RefClass classCraftWorld = getRefClass("{cb}.CraftWorld");
+    private final ReflectionUtils.RefMethod methodGetHandle;
+    private final ReflectionUtils.RefMethod methodGetChunkAt;
+    private final ReflectionUtils.RefMethod methodA;
+    private final ReflectionUtils.RefMethod methodGetById;
+    private final ReflectionUtils.RefMethod methodInitLighting;
+    private final SendChunk sendChunk;
+
+    private final HashMap<ChunkWrapper, Chunk> toUpdate = new HashMap<>();
+
+    public BukkitLocalQueue_1_7(String world) throws NoSuchMethodException, ClassNotFoundException, NoSuchFieldException {
+        super(world);
+        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 (BukkitLocalQueue_1_7.this.toUpdate.isEmpty()) {
+                    return;
+                }
+                int count = 0;
+                ArrayList<Chunk> chunks = new ArrayList<>();
+                Iterator<Map.Entry<ChunkWrapper, Chunk>> i = BukkitLocalQueue_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;
+        }
+    }
+
+    @Override
+    public void fixChunkLighting(int x, int z) {
+        Object c = this.methodGetHandle.of(getChunk(x, z)).call();
+        this.methodInitLighting.of(c).call();
+    }
+
+    @Override
+    public void setBlocks(LocalChunk<PlotBlock[]> lc) {
+        Chunk chunk = getChunk(lc.getX(), lc.getZ());
+        chunk.load(true);
+        World world = chunk.getWorld();
+        ChunkWrapper wrapper = new ChunkWrapper(getWorld(), lc.getX(), lc.getZ());
+        if (!this.toUpdate.containsKey(wrapper)) {
+            this.toUpdate.put(wrapper, chunk);
+        }
+        Object w = this.methodGetHandle.of(world).call();
+        Object c = this.methodGetChunkAt.of(w).call(lc.getX(), lc.getZ());
+        for (int i = 0; i < lc.blocks.length; i++) {
+            PlotBlock[] result2 = lc.blocks[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);
+            }
+        }
+        fixChunkLighting(lc.getX(), lc.getZ());
+    }
+
+    @Override
+    public void refreshChunk(int x, int z) {
+        update(Arrays.asList(Bukkit.getWorld(getWorld()).getChunkAt(x, z)));
+    }
+}

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

@@ -1,65 +1,61 @@
 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.ChunkWrapper;
 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.ReflectionUtils;
 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.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Iterator;
-import java.util.Map.Entry;
+import java.util.Map;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.block.Block;
 
-public class FastQueue_1_8 extends SlowQueue {
 
-    public 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");
-    public HashMap<ChunkWrapper, Chunk> toUpdate = new HashMap<>();
-    private RefMethod methodGetHandle;
-    private RefMethod methodGetChunkAt;
-    private RefMethod methodA;
-    private RefMethod methodGetByCombinedId;
-    private RefConstructor constructorBlockPosition;
-    private SendChunk chunksender;
+import static com.intellectualcrafters.plot.util.ReflectionUtils.getRefClass;
 
-    public FastQueue_1_8() throws NoSuchMethodException, RuntimeException {
-        methodInitLighting = classChunk.getMethod("initLighting");
-        constructorBlockPosition = classBlockPosition.getConstructor(int.class, int.class, int.class);
-        methodGetByCombinedId = classBlock.getMethod("getByCombinedId", int.class);
-        methodGetHandle = classCraftWorld.getMethod("getHandle");
-        methodGetChunkAt = classWorld.getMethod("getChunkAt", int.class, int.class);
-        methodA = classChunk.getMethod("a", classBlockPosition, classIBlockData);
-        chunksender = new SendChunk();
+public class BukkitLocalQueue_1_8 extends BukkitLocalQueue<PlotBlock[]> {
+
+    private final ReflectionUtils.RefMethod methodInitLighting;
+    private final ReflectionUtils.RefClass classBlock = getRefClass("{nms}.Block");
+    private final ReflectionUtils.RefClass classBlockPosition = getRefClass("{nms}.BlockPosition");
+    private final ReflectionUtils.RefClass classIBlockData = getRefClass("{nms}.IBlockData");
+    private final ReflectionUtils.RefClass classChunk = getRefClass("{nms}.Chunk");
+    private final ReflectionUtils.RefClass classWorld = getRefClass("{nms}.World");
+    private final ReflectionUtils.RefClass classCraftWorld = getRefClass("{cb}.CraftWorld");
+    private final HashMap<ChunkWrapper, Chunk> toUpdate = new HashMap<>();
+    private final ReflectionUtils.RefMethod methodGetHandle;
+    private final ReflectionUtils.RefMethod methodGetChunkAt;
+    private final ReflectionUtils.RefMethod methodA;
+    private final ReflectionUtils.RefMethod methodGetByCombinedId;
+    private final ReflectionUtils.RefConstructor constructorBlockPosition;
+    private final SendChunk sendChunk;
+
+    public BukkitLocalQueue_1_8(String world) throws NoSuchMethodException, ClassNotFoundException, NoSuchFieldException {
+        super(world);
+        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 (toUpdate.isEmpty()) {
+                if (BukkitLocalQueue_1_8.this.toUpdate.isEmpty()) {
                     return;
                 }
                 int count = 0;
-                final ArrayList<Chunk> chunks = new ArrayList<Chunk>();
-                final Iterator<Entry<ChunkWrapper, Chunk>> i = toUpdate.entrySet().iterator();
-                while (i.hasNext() && (count < 128)) {
+                ArrayList<Chunk> chunks = new ArrayList<>();
+                Iterator<Map.Entry<ChunkWrapper, Chunk>> i = BukkitLocalQueue_1_8.this.toUpdate.entrySet().iterator();
+                while (i.hasNext() && count < 128) {
                     chunks.add(i.next().getValue());
                     i.remove();
                     count++;
@@ -73,51 +69,32 @@ public class FastQueue_1_8 extends SlowQueue {
         MainUtil.initCache();
     }
 
-    public void update(final Collection<Chunk> chunks) {
-        if (chunks.isEmpty()) {
-            return;
-        }
-        if (!MainUtil.canSendChunk) {
-            for (final Chunk chunk : chunks) {
-                chunk.getWorld().refreshChunk(chunk.getX(), chunk.getZ());
-                chunk.unload(true, false);
-                chunk.load();
-            }
-            return;
-        }
-        try {
-            chunksender.sendChunk(chunks);
-        } catch (final Throwable e) {
-            e.printStackTrace();
-            MainUtil.canSendChunk = false;
-        }
+    @Override
+    public void fixChunkLighting(int x, int z) {
+        Object c = this.methodGetHandle.of(getChunk(x, z)).call();
+        this.methodInitLighting.of(c).call();
     }
 
-    /**
-     * This should be overriden by any specialized queues 
-     * @param pc
-     */
     @Override
-    public void execute(PlotChunk<Chunk> pc) {
-        SlowChunk sc = (SlowChunk) pc;
-        Chunk chunk = pc.getChunk();
-        ChunkWrapper wrapper = pc.getChunkWrapper();
-        if (!toUpdate.containsKey(wrapper)) {
-            toUpdate.put(wrapper, chunk);
-        }
+    public void setBlocks(LocalChunk<PlotBlock[]> lc) {
+        Chunk chunk = getChunk(lc.getX(), lc.getZ());
         chunk.load(true);
         World world = chunk.getWorld();
-        final Object w = methodGetHandle.of(world).call();
-        final Object c = methodGetChunkAt.of(w).call(wrapper.x, wrapper.z);
-        for (int i = 0; i < sc.result.length; i++) {
-            PlotBlock[] result2 = sc.result[i];
+        ChunkWrapper wrapper = new ChunkWrapper(getWorld(), lc.getX(), lc.getZ());
+        if (!this.toUpdate.containsKey(wrapper)) {
+            this.toUpdate.put(wrapper, chunk);
+        }
+        Object w = this.methodGetHandle.of(world).call();
+        Object c = this.methodGetChunkAt.of(w).call(lc.getX(), lc.getZ());
+        for (int i = 0; i < lc.blocks.length; i++) {
+            PlotBlock[] result2 = lc.blocks[i];
             if (result2 == null) {
                 continue;
             }
             for (int j = 0; j < 4096; j++) {
-                final int x = MainUtil.x_loc[i][j];
-                final int y = MainUtil.y_loc[i][j];
-                final int z = MainUtil.z_loc[i][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);
@@ -161,8 +138,8 @@ public class FastQueue_1_8 extends SlowQueue {
                     case 29:
                     case 33:
                     case 151:
-                    case 178: {
-                        final Block block = world.getBlockAt(x, y, z);
+                    case 178:
+                        Block block = world.getBlockAt(x, y, z);
                         if (block.getData() == newBlock.data) {
                             if (block.getTypeId() != newBlock.id) {
                                 block.setTypeId(newBlock.id, false);
@@ -175,12 +152,11 @@ public class FastQueue_1_8 extends SlowQueue {
                             }
                         }
                         continue;
-                    }
                 }
 
                 // Start data value shortcut
-                final Block block = world.getBlockAt(x, y, z);
-                final int currentId = block.getTypeId();
+                Block block = world.getBlockAt(x, y, z);
+                int currentId = block.getTypeId();
                 if (currentId == newBlock.id) {
                     switch (newBlock.id) {
                         case 0:
@@ -263,9 +239,8 @@ public class FastQueue_1_8 extends SlowQueue {
                         case 189:
                         case 190:
                         case 191:
-                        case 192: {
+                        case 192:
                             continue;
-                        }
                     }
                     if (block.getData() == newBlock.data) {
                         return;
@@ -311,74 +286,52 @@ public class FastQueue_1_8 extends SlowQueue {
                     case 29:
                     case 33:
                     case 151:
-                    case 178: {
+                    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
-                final Object pos = constructorBlockPosition.create(x, y, z);
-                final Object combined = methodGetByCombinedId.call(newBlock.id + (newBlock.data << 12));
-                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]);
+                Object pos = null;
+                try {
+                    pos = this.constructorBlockPosition.create(x, y, z);
+                } catch (ReflectiveOperationException e) {
+                    e.printStackTrace();
                 }
+                Object combined = this.methodGetByCombinedId.call(newBlock.id + (newBlock.data << 12));
+                this.methodA.of(chunk).call(pos, combined);
             }
         }
+        fixChunkLighting(lc.getX(), lc.getZ());
+    }
+
+    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 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 = methodGetHandle.of(chunk.getChunk()).call();
-        methodInitLighting.of(c).call();
-        return true;
-    }
-
-    /**
-     * This should be overridden by any specialized queues
-     * @param locs
-     */
-    @Override
-    public void sendChunk(String world, Collection<ChunkLoc> locs) {
-        World worldObj = BukkitUtil.getWorld(world);
-        for (ChunkLoc loc : locs) {
-            ChunkWrapper wrapper = SetQueue.IMP.new ChunkWrapper(world, loc.x, loc.z);
-            if (!toUpdate.containsKey(wrapper)) {
-                toUpdate.put(wrapper, worldObj.getChunkAt(loc.x, loc.z));
-            }
-        }
+    public void refreshChunk(int x, int z) {
+        update(Arrays.asList(Bukkit.getWorld(getWorld()).getChunkAt(x, z)));
     }
 }

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

@@ -0,0 +1,537 @@
+package com.plotsquared.bukkit.util.block;
+
+import com.intellectualcrafters.plot.object.ChunkLoc;
+import com.intellectualcrafters.plot.object.ChunkWrapper;
+import com.intellectualcrafters.plot.object.PseudoRandom;
+import com.intellectualcrafters.plot.util.ChunkManager;
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.ReflectionUtils;
+import com.intellectualcrafters.plot.util.TaskManager;
+import com.intellectualcrafters.plot.util.block.BasicLocalBlockQueue;
+import com.plotsquared.bukkit.util.SendChunk;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.Material;
+import org.bukkit.World;
+
+
+import static com.intellectualcrafters.plot.util.ReflectionUtils.getRefClass;
+
+public class BukkitLocalQueue_1_8_3 extends BukkitLocalQueue<char[]> {
+
+    private final SendChunk sendChunk;
+    private final HashMap<ChunkWrapper, Chunk> toUpdate = new HashMap<>();
+    private final ReflectionUtils.RefMethod methodGetHandleChunk;
+    private final ReflectionUtils.RefMethod methodGetHandleWorld;
+    private final ReflectionUtils.RefMethod methodInitLighting;
+    private final ReflectionUtils.RefConstructor classBlockPositionConstructor;
+    private final ReflectionUtils.RefConstructor classChunkSectionConstructor;
+    private final ReflectionUtils.RefMethod methodX;
+    private final ReflectionUtils.RefMethod methodAreNeighborsLoaded;
+    private final ReflectionUtils.RefField fieldSections;
+    private final ReflectionUtils.RefField fieldWorld;
+    private final ReflectionUtils.RefMethod methodGetIdArray;
+    private final ReflectionUtils.RefMethod methodGetWorld;
+    private final ReflectionUtils.RefField tileEntityListTick;
+
+    public BukkitLocalQueue_1_8_3(String world) throws NoSuchMethodException, ClassNotFoundException, NoSuchFieldException {
+        super(world);
+        ReflectionUtils.RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
+        ReflectionUtils.RefClass classCraftWorld = getRefClass("{cb}.CraftWorld");
+        this.methodGetHandleChunk = classCraftChunk.getMethod("getHandle");
+        ReflectionUtils.RefClass classChunk = getRefClass("{nms}.Chunk");
+        this.methodInitLighting = classChunk.getMethod("initLighting");
+        ReflectionUtils.RefClass classBlockPosition = getRefClass("{nms}.BlockPosition");
+        this.classBlockPositionConstructor = classBlockPosition.getConstructor(int.class, int.class, int.class);
+        ReflectionUtils.RefClass classWorld = getRefClass("{nms}.World");
+        this.methodX = classWorld.getMethod("x", classBlockPosition.getRealClass());
+        this.fieldSections = classChunk.getField("sections");
+        this.fieldWorld = classChunk.getField("world");
+        ReflectionUtils.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.methodGetHandleWorld = classCraftWorld.getMethod("getHandle");
+        this.methodGetWorld = classChunk.getMethod("getWorld");
+        this.sendChunk = new SendChunk();
+        TaskManager.runTaskRepeat(new Runnable() {
+            @Override
+            public void run() {
+                if (BukkitLocalQueue_1_8_3.this.toUpdate.isEmpty()) {
+                    return;
+                }
+                int count = 0;
+                ArrayList<Chunk> chunks = new ArrayList<>();
+                Iterator<Map.Entry<ChunkWrapper, Chunk>> i = BukkitLocalQueue_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();
+    }
+
+    @Override
+    public LocalChunk<char[]> getLocalChunk(int x, int z) {
+        return new CharLocalChunk_1_8_3(this, x, z);
+    }
+
+    public class CharLocalChunk_1_8_3 extends CharLocalChunk {
+        public short[] count;
+        public short[] air;
+        public short[] relight;
+
+        public CharLocalChunk_1_8_3(BasicLocalBlockQueue parent, int x, int z) {
+            super(parent, x, z);
+            this.count = new short[16];
+            this.air = new short[16];
+            this.relight = new short[16];
+        }
+
+        @Override
+        public void setBlock(int x, int y, int z, int id, int data) {
+            int i = MainUtil.CACHE_I[y][x][z];
+            int j = MainUtil.CACHE_J[y][x][z];
+            char[] vs = this.blocks[i];
+            if (vs == null) {
+                vs = this.blocks[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;
+            }
+        }
+
+        public char[] getIdArray(int i) {
+            return this.blocks[i];
+        }
+
+        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;
+        }
+
+        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;
+        }
+    }
+
+    @Override
+    public void setBlocks(LocalChunk lc) {
+        CharLocalChunk_1_8_3 fs = (CharLocalChunk_1_8_3) lc;
+        Chunk chunk = getChunk(lc.getX(), lc.getZ());
+        chunk.load(true);
+        World world = chunk.getWorld();
+        ChunkWrapper wrapper = new ChunkWrapper(getWorld(), lc.getX(), lc.getZ());
+        if (!this.toUpdate.containsKey(wrapper)) {
+            this.toUpdate.put(wrapper, chunk);
+        }
+        try {
+            boolean flag = world.getEnvironment() == World.Environment.NORMAL;
+
+            // Sections
+            Method getHandle = chunk.getClass().getDeclaredMethod("getHandle");
+            Object c = getHandle.invoke(chunk);
+            Object w = this.methodGetWorld.of(c).call();
+            Class<?> 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<Map.Entry<?, ?>> entrySet = (Set<Map.Entry<?, ?>>) (Set<?>) tiles.entrySet();
+            Iterator<Map.Entry<?, ?>> iterator = entrySet.iterator();
+            while (iterator.hasNext()) {
+                Map.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 (IllegalArgumentException | SecurityException | ReflectiveOperationException e) {
+            e.printStackTrace();
+        }
+        fixLighting(chunk, fs, true);
+    }
+
+    public Object newChunkSection(int i, boolean flag, char[] ids) throws ReflectiveOperationException {
+        return this.classChunkSectionConstructor.create(i, flag, ids);
+    }
+
+    public char[] getIdArray(Object obj) {
+        return (char[]) this.methodGetIdArray.of(obj).call();
+    }
+
+    @Override
+    public void fixChunkLighting(int x, int z) {
+        Object c = this.methodGetHandleChunk.of(getChunk(x, z)).call();
+        this.methodInitLighting.of(c).call();
+    }
+
+    public boolean fixLighting(Chunk chunk, CharLocalChunk_1_8_3 bc, boolean fixAll) {
+        try {
+            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 = new ChunkWrapper(getWorld(), chunk.getX(), chunk.getZ());
+                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(wrapper.world, 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;
+
+            ReflectionUtils.RefMethod.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;
+    }
+
+    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;
+        }
+    }
+
+    @Override
+    public void refreshChunk(int x, int z) {
+        update(Arrays.asList(Bukkit.getWorld(getWorld()).getChunkAt(x, z)));
+    }
+}

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

@@ -0,0 +1,514 @@
+package com.plotsquared.bukkit.util.block;
+
+import com.intellectualcrafters.plot.object.ChunkLoc;
+import com.intellectualcrafters.plot.object.ChunkWrapper;
+import com.intellectualcrafters.plot.object.PseudoRandom;
+import com.intellectualcrafters.plot.util.ChunkManager;
+import com.intellectualcrafters.plot.util.MainUtil;
+import com.intellectualcrafters.plot.util.ReflectionUtils;
+import com.intellectualcrafters.plot.util.block.BasicLocalBlockQueue;
+import java.lang.reflect.Field;
+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;
+import java.util.Set;
+import org.bukkit.Chunk;
+import org.bukkit.Material;
+import org.bukkit.World;
+
+
+import static com.intellectualcrafters.plot.util.ReflectionUtils.getRefClass;
+
+public class BukkitLocalQueue_1_9 extends BukkitLocalQueue<char[]> {
+
+    private final Object air;
+    //    private final HashMap<ChunkWrapper, Chunk> toUpdate = new HashMap<>();
+    private final ReflectionUtils.RefMethod methodGetHandleChunk;
+    private final ReflectionUtils.RefMethod methodInitLighting;
+    private final ReflectionUtils.RefConstructor classBlockPositionConstructor;
+    private final ReflectionUtils.RefConstructor classChunkSectionConstructor;
+    private final ReflectionUtils.RefMethod methodW;
+    private final ReflectionUtils.RefMethod methodAreNeighborsLoaded;
+    private final ReflectionUtils.RefField fieldSections;
+    private final ReflectionUtils.RefField fieldWorld;
+    private final ReflectionUtils.RefMethod methodGetBlocks;
+    private final ReflectionUtils.RefMethod methodGetType;
+    private final ReflectionUtils.RefMethod methodSetType;
+    private final ReflectionUtils.RefMethod methodGetCombinedId;
+    private final ReflectionUtils.RefMethod methodGetByCombinedId;
+    private final ReflectionUtils.RefMethod methodGetWorld;
+
+    private final ReflectionUtils.RefField tileEntityListTick;
+
+    public BukkitLocalQueue_1_9(String world) throws NoSuchMethodException, ClassNotFoundException, NoSuchFieldException {
+        super(world);
+        ReflectionUtils.RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
+        this.methodGetHandleChunk = classCraftChunk.getMethod("getHandle");
+        ReflectionUtils.RefClass classChunk = getRefClass("{nms}.Chunk");
+        this.methodInitLighting = classChunk.getMethod("initLighting");
+        ReflectionUtils.RefClass classBlockPosition = getRefClass("{nms}.BlockPosition");
+        this.classBlockPositionConstructor = classBlockPosition.getConstructor(int.class, int.class, int.class);
+        ReflectionUtils.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");
+        ReflectionUtils.RefClass classBlock = getRefClass("{nms}.Block");
+        ReflectionUtils.RefClass classIBlockData = getRefClass("{nms}.IBlockData");
+        this.methodGetCombinedId = classBlock.getMethod("getCombinedId", classIBlockData.getRealClass());
+        this.methodGetByCombinedId = classBlock.getMethod("getByCombinedId", int.class);
+        ReflectionUtils.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();
+    }
+
+    @Override
+    public LocalChunk<char[]> getLocalChunk(int x, int z) {
+        return new CharLocalChunk_1_8_3(this, x, z);
+    }
+
+    public class CharLocalChunk_1_8_3 extends CharLocalChunk {
+        public short[] count;
+        public short[] air;
+        public short[] relight;
+
+        public CharLocalChunk_1_8_3(BasicLocalBlockQueue parent, int x, int z) {
+            super(parent, x, z);
+            this.count = new short[16];
+            this.air = new short[16];
+            this.relight = new short[16];
+        }
+
+        @Override
+        public void setBlock(int x, int y, int z, int id, int data) {
+            int i = MainUtil.CACHE_I[y][x][z];
+            int j = MainUtil.CACHE_J[y][x][z];
+            char[] vs = this.blocks[i];
+            if (vs == null) {
+                vs = this.blocks[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;
+            }
+        }
+
+        public char[] getIdArray(int i) {
+            return this.blocks[i];
+        }
+
+        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;
+        }
+
+        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;
+        }
+    }
+
+    @Override
+    public void setBlocks(LocalChunk lc) {
+        CharLocalChunk_1_8_3 fs = (CharLocalChunk_1_8_3) lc;
+        Chunk chunk = getChunk(lc.getX(), lc.getZ());
+        chunk.load(true);
+        World world = chunk.getWorld();
+        try {
+            boolean flag = world.getEnvironment() == World.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<Map.Entry<?, ?>> entrySet = (Set<Map.Entry<?, ?>>) (Set<?>) tiles.entrySet();
+            Iterator<Map.Entry<?, ?>> iterator = entrySet.iterator();
+            while (iterator.hasNext()) {
+                Map.Entry<?, ?> tile = iterator.next();
+                Object pos = tile.getKey();
+                if (xm == null) {
+                    Class<?> 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];
+                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, fs.getIdArray(j));
+                    continue;
+                }
+                Object currentArray = getBlocks(section);
+                ReflectionUtils.RefMethod.RefExecutor setType = this.methodSetType.of(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;
+                            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];
+                            int id = n >> 4;
+                            int data = n & 15;
+                            Object iBlock = this.methodGetByCombinedId.call((int) (id & 0xFFF) + (data << 12));
+                            setType.call(x, y & 15, z, iBlock);
+                    }
+                }
+                if (fill) {
+                    fs.setCount(j, Short.MAX_VALUE);
+                }
+            }
+            // Clear
+        } catch (IllegalArgumentException | SecurityException | ReflectiveOperationException e) {
+            e.printStackTrace();
+        }
+        fixLighting(chunk, fs, true);
+        refreshChunk(fs.getX(), fs.getZ());
+    }
+
+    public Object newChunkSection(int i, boolean flag, char[] ids) throws ReflectiveOperationException {
+        return this.classChunkSectionConstructor.create(i, flag, ids);
+    }
+
+    public Object getBlocks(Object obj) {
+        return this.methodGetBlocks.of(obj).call();
+    }
+
+    @Override
+    public void fixChunkLighting(int x, int z) {
+        Object c = this.methodGetHandleChunk.of(getChunk(x, z)).call();
+        this.methodInitLighting.of(c).call();
+    }
+
+    public boolean fixLighting(Chunk chunk, CharLocalChunk_1_8_3 bc, boolean fixAll) {
+        try {
+            if (!chunk.isLoaded()) {
+                chunk.load(false);
+            } else {
+                chunk.unload(true, false);
+                chunk.load(false);
+            }
+
+            // Initialize lighting
+            Object c = this.methodGetHandleChunk.of(chunk).call();
+
+            ChunkWrapper wrapper = new ChunkWrapper(getWorld(), bc.getX(), bc.getZ());
+            if (fixAll && !(boolean) this.methodAreNeighborsLoaded.of(c).call(1)) {
+                World world = chunk.getWorld();
+                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(getWorld(), 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;
+
+            ReflectionUtils.RefMethod.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;
+                }
+                char[] 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.blocks, 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;
+    }
+
+    @Override
+    public void refreshChunk(int x, int z) {
+        getBukkitWorld().refreshChunk(x, z);
+    }
+
+    public boolean isSurrounded(char[][] 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(char[] section, int x, int y, int z) {
+        if (section == null) {
+            return 0;
+        }
+        int j = MainUtil.CACHE_J[y][x][z];
+        return section[j] >> 4;
+    }
+
+    public int getId(char[][] 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];
+        char[] section = sections[i];
+        if (section == null) {
+            return 0;
+        }
+        return getId(section, x, y, z);
+    }
+}

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

@@ -1,246 +0,0 @@
-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(final ChunkWrapper chunk) {
-        super(chunk);
-        ids = new char[16][];
-        count = new short[16];
-        air = new short[16];
-        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 (chunk == null) {
-            final ChunkWrapper cl = getChunkWrapper();
-            chunk = Bukkit.getWorld(cl.world).getChunkAt(cl.x, cl.z);
-        }
-        return chunk;
-    }
-
-    @Override
-    public void setChunkWrapper(final ChunkWrapper loc) {
-        super.setChunkWrapper(loc);
-        chunk = null;
-    }
-
-    /**
-     * Get the number of block changes in a specified section
-     * @param i
-     * @return
-     */
-    public int getCount(final int i) {
-        return count[i];
-    }
-
-    public int getAir(final int i) {
-        return air[i];
-    }
-
-    public void setCount(int i, short value) {
-        count[i] = value;
-    }
-
-    /**
-     * Get the number of block changes in a specified section
-     * @param i
-     * @return
-     */
-    public int getRelight(final int i) {
-        return relight[i];
-    }
-
-    public int getTotalCount() {
-        int total = 0;
-        for (int i = 0; i < 16; i++) {
-            total += count[i];
-        }
-        return total;
-    }
-
-    public int getTotalRelight() {
-        if (getTotalCount() == 0) {
-            Arrays.fill(count, (short) 1);
-            Arrays.fill(relight, Short.MAX_VALUE);
-            return Short.MAX_VALUE;
-        }
-        int total = 0;
-        for (int i = 0; i < 16; i++) {
-            total += relight[i];
-        }
-        return total;
-    }
-
-    /**
-     * Get the raw data for a section
-     * @param i
-     * @return
-     */
-    public char[] getIdArray(final int i) {
-        return ids[i];
-    }
-
-    @Override
-    public void setBlock(final int x, final int y, final int z, final int id, byte data) {
-        final int i = MainUtil.CACHE_I[y][x][z];
-        final int j = MainUtil.CACHE_J[y][x][z];
-        char[] vs = ids[i];
-        if (vs == null) {
-            vs = ids[i] = new char[4096];
-            count[i]++;
-        } else if (vs[j] == 0) {
-            count[i]++;
-        }
-        switch (id) {
-            case 0:
-                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:
-                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:
-                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 = air.clone();
-        toReturn.count = count.clone();
-        toReturn.relight = relight.clone();
-        toReturn.ids = new char[ids.length][];
-        for (int i = 0; i < ids.length; i++) {
-            char[] matrix = 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 = air;
-        toReturn.count = count;
-        toReturn.relight = relight;
-        toReturn.ids = ids;
-        return toReturn;
-    }
-
-    @Override
-    public void setBiome(int x, int z, int biome) {
-        if (biomes == null) {
-            biomes = new int[16][16];
-        }
-        biomes[x][z] = biome;
-    }
-}

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

@@ -1,35 +0,0 @@
-package com.plotsquared.bukkit.util.block;
-
-import com.intellectualcrafters.plot.util.PlotChunk;
-import com.intellectualcrafters.plot.util.SetQueue;
-import com.plotsquared.bukkit.util.BukkitUtil;
-import org.bukkit.Chunk;
-
-public class FastChunk_1_9 extends PlotChunk<Chunk> {
-
-    public FastChunk_1_9(SetQueue.ChunkWrapper wrap) {
-        super(wrap);
-    }
-
-    @Override
-    public Chunk getChunkAbs() {
-        SetQueue.ChunkWrapper loc = getChunkWrapper();
-        return BukkitUtil.getWorld(loc.world).getChunkAt(loc.x, loc.z);
-    }
-
-    @Override public void setBlock(int x, int y, int z, int id, byte data) {
-
-    }
-
-    @Override public void setBiome(int x, int z, int biome) {
-
-    }
-
-    @Override public PlotChunk clone() {
-        return null;
-    }
-
-    @Override public PlotChunk shallowClone() {
-        return null;
-    }
-}

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

@@ -1,181 +0,0 @@
-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 {
-
-    public final RefClass classBlock = getRefClass("{nms}.Block");
-    public final RefClass classChunk = getRefClass("{nms}.Chunk");
-    public final RefClass classWorld = getRefClass("{nms}.World");
-    public final RefClass classCraftWorld = getRefClass("{cb}.CraftWorld");
-    public final RefMethod methodGetHandle;
-    public final RefMethod methodGetChunkAt;
-    public final RefMethod methodA;
-    public final RefMethod methodGetById;
-    public final RefMethod methodInitLighting;
-
-    public final SendChunk chunksender;
-
-    public HashMap<ChunkWrapper, Chunk> toUpdate = new HashMap<>();
-
-    public FastQueue_1_7() throws NoSuchMethodException, RuntimeException {
-        methodGetHandle = classCraftWorld.getMethod("getHandle");
-        methodGetChunkAt = classWorld.getMethod("getChunkAt", int.class, int.class);
-        methodA = classChunk.getMethod("a", int.class, int.class, int.class, classBlock, int.class);
-        methodGetById = classBlock.getMethod("getById", int.class);
-        methodInitLighting = classChunk.getMethod("initLighting");
-        chunksender = new SendChunk();
-        TaskManager.runTaskRepeat(new Runnable() {
-            @Override
-            public void run() {
-                if (toUpdate.isEmpty()) {
-                    return;
-                }
-                int count = 0;
-                final ArrayList<Chunk> chunks = new ArrayList<>();
-                final Iterator<Entry<ChunkWrapper, Chunk>> i = 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(final Collection<Chunk> chunks) {
-        if (chunks.isEmpty()) {
-            return;
-        }
-        if (!MainUtil.canSendChunk) {
-            for (final Chunk chunk : chunks) {
-                chunk.getWorld().refreshChunk(chunk.getX(), chunk.getZ());
-                chunk.unload(true, false);
-                chunk.load();
-            }
-            return;
-        }
-        try {
-            chunksender.sendChunk(chunks);
-        } catch (final Throwable e) {
-            e.printStackTrace();
-            MainUtil.canSendChunk = false;
-        }
-    }
-
-    /**
-     * This should be overridden by any specialized queues
-     * @param pc
-     */
-    @Override
-    public void execute(PlotChunk<Chunk> pc) {
-        SlowChunk sc = (SlowChunk) pc;
-        Chunk chunk = pc.getChunk();
-        ChunkWrapper wrapper = pc.getChunkWrapper();
-        if (!toUpdate.containsKey(wrapper)) {
-            toUpdate.put(wrapper, chunk);
-        }
-        chunk.load(true);
-        World world = chunk.getWorld();
-        final Object w = methodGetHandle.of(world).call();
-        final Object c = 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++) {
-                final int x = MainUtil.x_loc[i][j];
-                final int y = MainUtil.y_loc[i][j];
-                final 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;
-                }
-                final Object block = methodGetById.call(newBlock.id);
-                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 overriden by any specialized queues 
-     * @param chunk
-     * @param fixAll
-     */
-    @Override
-    public boolean fixLighting(PlotChunk<Chunk> chunk, boolean fixAll) {
-        Object c = methodGetHandle.of(chunk.getChunk()).call();
-        methodInitLighting.of(c).call();
-        return true;
-    }
-
-    /**
-     * This should be overridden by any specialized queues
-     * @param world
-     * @param locs
-     */
-    @Override
-    public void sendChunk(String world, Collection<ChunkLoc> locs) {
-        World worldObj = BukkitUtil.getWorld(world);
-        for (ChunkLoc loc : locs) {
-            ChunkWrapper wrapper = SetQueue.IMP.new ChunkWrapper(world, loc.x, loc.z);
-            if (!toUpdate.containsKey(wrapper)) {
-                toUpdate.put(wrapper, worldObj.getChunkAt(loc.x, loc.z));
-            }
-        }
-    }
-}

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

@@ -1,415 +0,0 @@
-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.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.BukkitUtil;
-import com.plotsquared.bukkit.util.SendChunk;
-import org.bukkit.Chunk;
-import org.bukkit.Material;
-import org.bukkit.World;
-import org.bukkit.World.Environment;
-import org.bukkit.block.Biome;
-
-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.List;
-import java.util.Map.Entry;
-import java.util.Set;
-
-public class FastQueue_1_8_3 extends SlowQueue {
-
-    public final SendChunk chunksender;
-    private final RefClass classEntityPlayer = getRefClass("{nms}.EntityPlayer");
-    private final RefClass classMapChunk = getRefClass("{nms}.PacketPlayOutMapChunk");
-    private final RefClass classPacket = getRefClass("{nms}.Packet");
-    private final RefClass classConnection = getRefClass("{nms}.PlayerConnection");
-    private final RefClass classChunk = getRefClass("{nms}.Chunk");
-    private final RefClass classCraftPlayer = getRefClass("{cb}.entity.CraftPlayer");
-    private final RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
-    private final RefClass classWorld = getRefClass("{nms}.World");
-    private final RefField mustSave = classChunk.getField("mustSave");
-    private final RefClass classBlockPosition = getRefClass("{nms}.BlockPosition");
-    private final RefClass classChunkSection = getRefClass("{nms}.ChunkSection");
-    public HashMap<ChunkWrapper, Chunk> toUpdate = new HashMap<>();
-    private RefMethod methodGetHandleChunk;
-    private RefConstructor MapChunk;
-    private RefMethod methodInitLighting;
-    private RefConstructor classBlockPositionConstructor;
-    private RefConstructor classChunkSectionConstructor;
-    private RefMethod methodX;
-    private RefMethod methodAreNeighborsLoaded;
-    private RefField fieldSections;
-    private RefField fieldWorld;
-    private RefMethod methodGetIdArray;
-
-    public FastQueue_1_8_3() throws NoSuchMethodException, RuntimeException {
-        methodGetHandleChunk = classCraftChunk.getMethod("getHandle");
-        methodInitLighting = classChunk.getMethod("initLighting");
-        MapChunk = classMapChunk.getConstructor(classChunk.getRealClass(), boolean.class, int.class);
-        classBlockPositionConstructor = classBlockPosition.getConstructor(int.class, int.class, int.class);
-        methodX = classWorld.getMethod("x", classBlockPosition.getRealClass());
-        fieldSections = classChunk.getField("sections");
-        fieldWorld = classChunk.getField("world");
-        methodGetIdArray = classChunkSection.getMethod("getIdArray");
-        methodAreNeighborsLoaded = classChunk.getMethod("areNeighborsLoaded", int.class);
-        classChunkSectionConstructor = classChunkSection.getConstructor(int.class, boolean.class, char[].class);
-        chunksender = new SendChunk();
-        TaskManager.runTaskRepeat(new Runnable() {
-            @Override
-            public void run() {
-                if (toUpdate.isEmpty()) {
-                    return;
-                }
-                int count = 0;
-                final ArrayList<Chunk> chunks = new ArrayList<Chunk>();
-                final Iterator<Entry<ChunkWrapper, Chunk>> i = 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(final Collection<Chunk> chunks) {
-        if (chunks.isEmpty()) {
-            return;
-        }
-        if (!MainUtil.canSendChunk) {
-            for (final Chunk chunk : chunks) {
-                chunk.getWorld().refreshChunk(chunk.getX(), chunk.getZ());
-                chunk.unload(true, false);
-                chunk.load();
-            }
-            return;
-        }
-        try {
-            chunksender.sendChunk(chunks);
-        } catch (final Throwable e) {
-            e.printStackTrace();
-            MainUtil.canSendChunk = false;
-        }
-    }
-
-    /**
-     * This should be overridden by any specialized queues
-     * @param pc
-     */
-    @Override
-    public void execute(PlotChunk<Chunk> pc) {
-        FastChunk_1_8_3 fs = (FastChunk_1_8_3) pc;
-        Chunk chunk = pc.getChunk();
-        final World world = chunk.getWorld();
-        ChunkWrapper wrapper = pc.getChunkWrapper();
-        if (!toUpdate.containsKey(wrapper)) {
-            toUpdate.put(wrapper, chunk);
-        }
-        chunk.load(true);
-        try {
-            final boolean flag = world.getEnvironment() == Environment.NORMAL;
-
-            // Sections
-            final Method getHandele = chunk.getClass().getDeclaredMethod("getHandle");
-            final Object c = getHandele.invoke(chunk);
-            final Class<? extends Object> clazz = c.getClass();
-            final Field sf = clazz.getDeclaredField("sections");
-            sf.setAccessible(true);
-            final Field tf = clazz.getDeclaredField("tileEntities");
-            final Field ef = clazz.getDeclaredField("entitySlices");
-
-            final Object[] sections = (Object[]) sf.get(c);
-            final HashMap<?, ?> tiles = (HashMap<?, ?>) tf.get(c);
-            final List<?>[] entities = (List<?>[]) ef.get(c);
-
-            Method xm = null;
-            Method ym = null;
-            Method zm = null;
-
-            // Trim tiles
-            final Set<Entry<?, ?>> entryset = (Set<Entry<?, ?>>) (Set<?>) tiles.entrySet();
-            final Iterator<Entry<?, ?>> iter = entryset.iterator();
-            while (iter.hasNext()) {
-                final Entry<?, ?> tile = iter.next();
-                final Object pos = tile.getKey();
-                if (xm == null) {
-                    final Class<? extends Object> clazz2 = pos.getClass().getSuperclass();
-                    xm = clazz2.getDeclaredMethod("getX");
-                    ym = clazz2.getDeclaredMethod("getY");
-                    zm = clazz2.getDeclaredMethod("getZ");
-                }
-                final int lx = (int) xm.invoke(pos) & 15;
-                final int ly = (int) ym.invoke(pos);
-                final int lz = (int) zm.invoke(pos) & 15;
-                final int j = MainUtil.CACHE_I[ly][lx][lz];
-                final int k = MainUtil.CACHE_J[ly][lx][lz];
-                final char[] array = fs.getIdArray(j);
-                if (array == null) {
-                    continue;
-                }
-                if (array[k] != 0) {
-                    iter.remove();
-                }
-            }
-
-            // 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;
-                }
-                final 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;
-                }
-                final char[] currentArray = getIdArray(section);
-                boolean fill = true;
-                for (int k = 0; k < newArray.length; k++) {
-                    final 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(final int i, final boolean flag, final char[] ids) {
-        return classChunkSectionConstructor.create(i, flag, ids);
-    }
-
-    public char[] getIdArray(final Object obj) {
-        return (char[]) 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 pc
-     */
-    @Override
-    public boolean fixLighting(PlotChunk<Chunk> pc, boolean fixAll) {
-        try {
-            FastChunk_1_8_3 bc = (FastChunk_1_8_3) pc;
-            final Chunk chunk = bc.getChunk();
-            if (!chunk.isLoaded()) {
-                chunk.load(false);
-            } else {
-                chunk.unload(true, false);
-                chunk.load(false);
-            }
-
-            // Initialize lighting
-            final Object c = methodGetHandleChunk.of(chunk).call();
-
-            if (fixAll && !(boolean) 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;
-                }
-            }
-
-            methodInitLighting.of(c).call();
-
-            if ((bc.getTotalRelight() == 0 && !fixAll)) {
-                return true;
-            }
-
-            final Object[] sections = (Object[]) fieldSections.of(c).get();
-            final Object w = fieldWorld.of(c).get();
-
-            final int X = chunk.getX() << 4;
-            final int Z = chunk.getZ() << 4;
-
-            RefExecutor relight = methodX.of(w);
-            for (int j = 0; j < sections.length; j++) {
-                final 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;
-                }
-                final char[] array = getIdArray(section);
-                int l = PseudoRandom.random.random(2);
-                for (int k = 0; k < array.length; k++) {
-                    final int i = array[k];
-                    if (i < 16) {
-                        continue;
-                    }
-                    final 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:
-                            final int x = MainUtil.x_loc[j][k];
-                            final int y = MainUtil.y_loc[j][k];
-                            final int z = MainUtil.z_loc[j][k];
-                            if (isSurrounded(sections, x, y, z)) {
-                                continue;
-                            }
-                            final Object pos = classBlockPositionConstructor.create(X + x, y, Z + z);
-                            relight.call(pos);
-                    }
-                }
-            }
-            return true;
-        } catch (final 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 locs
-     */
-    @Override
-    public void sendChunk(String world, Collection<ChunkLoc> locs) {
-        World worldObj = BukkitUtil.getWorld(world);
-        for (ChunkLoc loc : locs) {
-            ChunkWrapper wrapper = SetQueue.IMP.new ChunkWrapper(world, loc.x, loc.z);
-            if (!toUpdate.containsKey(wrapper)) {
-                toUpdate.put(wrapper, worldObj.getChunkAt(loc.x, loc.z));
-            }
-        }
-    }
-}

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

@@ -1,12 +0,0 @@
-package com.plotsquared.bukkit.util.block;
-
-import com.intellectualcrafters.plot.util.PlotChunk;
-import com.intellectualcrafters.plot.util.SetQueue;
-import org.bukkit.Chunk;
-
-public class FastQueue_1_9 extends SlowQueue {
-
-    @Override public PlotChunk<Chunk> getChunk(SetQueue.ChunkWrapper wrap) {
-        return new FastChunk_1_9(wrap);
-    }
-}

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

@@ -1,110 +1,202 @@
 package com.plotsquared.bukkit.util.block;
 
+import com.intellectualcrafters.plot.object.ChunkWrapper;
+import com.intellectualcrafters.plot.object.Location;
+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.intellectualcrafters.plot.util.block.ScopedLocalBlockQueue;
 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;
+import org.bukkit.material.MaterialData;
 
-public class GenChunk extends PlotChunk<Chunk> {
+public class GenChunk extends ScopedLocalBlockQueue {
 
     public final Biome[] biomes;
-    public Chunk chunk;
     public short[][] result;
     public byte[][] result_data;
     public ChunkData cd;
-    public boolean modified = false;
     public BiomeGrid grid;
 
+    public Chunk chunk;
+    public String world;
+    public int cx;
+    public int cz;
+
     public GenChunk(Chunk chunk, ChunkWrapper wrap) {
-        super(wrap);
-        if ((this.chunk = chunk) == null && wrap != null) {
+        super(null, new Location(null, 0, 0, 0), new Location(null, 15, 255, 15));
+        if ((this.chunk = chunk) == null && (wrap) != null) {
             World world = BukkitUtil.getWorld(wrap.world);
             if (world != null) {
-                chunk = world.getChunkAt(wrap.x, wrap.z);
+                this.chunk = world.getChunkAt(wrap.x, wrap.z);
             }
         }
         this.biomes = Biome.values();
     }
 
-    @Override
-    public Chunk getChunkAbs() {
-        ChunkWrapper wrap = getChunkWrapper();
-        if (chunk == null || wrap.x != chunk.getX() || wrap.z != chunk.getZ()) {
-            chunk = BukkitUtil.getWorld(wrap.world).getChunkAt(wrap.x, wrap.z);
+    public void setChunk(Chunk chunk) {
+        this.chunk = chunk;
+    }
+
+    public void setChunk(ChunkWrapper wrap) {
+        chunk = null;
+        world = wrap.world;
+        cx = wrap.x;
+        cz = wrap.z;
+    }
+
+    public Chunk getChunk() {
+        if (chunk == null) {
+            World worldObj = BukkitUtil.getWorld(world);
+            if (worldObj != null) {
+                this.chunk = worldObj.getChunkAt(cx, cz);
+            }
         }
         return chunk;
     }
 
-    @Override
-    public void setBiome(int x, int z, int biome) {
-        modified = true;
-        grid.setBiome(x, z, biomes[biome]);
-    }
-
-    public void setBiome(int x, int z, Biome biome) {
-        if (grid != null) {
-            grid.setBiome(x, z, biome);
+    public ChunkWrapper getChunkWrapper() {
+        if (chunk == null) {
+            return new ChunkWrapper(world, cx, cz);
         }
+        return new ChunkWrapper(chunk.getWorld().getName(), chunk.getX(), chunk.getZ());
     }
 
     @Override
-    public void setBlock(int x, int y, int z, int id, byte data) {
-        if (result == null) {
-            modified = true;
-            cd.setBlock(x, y, z, id, data);
+    public void fillBiome(String biomeName) {
+        if (grid == null) {
             return;
         }
+        Biome biome = Biome.valueOf(biomeName.toUpperCase());
+        for (int x = 0; x < 16; x++) {
+            for (int z = 0; z < 16; z++) {
+                this.grid.setBiome(x, z, biome);
+            }
+        }
+    }
+
+    @Override
+    public boolean setBiome(int x, int z, String biome) {
+        return setBiome(x, z, Biome.valueOf(biome.toUpperCase()));
+    }
+
+    public boolean setBiome(int x, int z, int biome) {
+        if (this.grid != null) {
+            this.grid.setBiome(x, z, this.biomes[biome]);
+            return true;
+        }
+        return false;
+    }
+
+    public boolean setBiome(int x, int z, Biome biome) {
+        if (this.grid != null) {
+            this.grid.setBiome(x, z, biome);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean setBlock(int x, int y, int z, int id, int data) {
+        if (this.result == null) {
+            this.cd.setBlock(x, y, z, id, (byte) data);
+            return true;
+        }
         int i = MainUtil.CACHE_I[y][x][z];
-        short[] v = result[i];
+        short[] v = this.result[i];
         if (v == null) {
-            modified = true;
-            result[i] = v = new short[4096];
+            this.result[i] = v = new short[4096];
         }
         int j = MainUtil.CACHE_J[y][x][z];
         v[j] = (short) id;
         if (data != 0) {
-            byte[] vd = result_data[i];
+            byte[] vd = this.result_data[i];
             if (vd == null) {
-                result_data[i] = vd = new byte[4096];
+                this.result_data[i] = vd = new byte[4096];
             }
-            vd[j] = data;
+            vd[j] = (byte) data;
         }
+        return true;
     }
 
     @Override
-    public PlotChunk clone() {
-        GenChunk toReturn = new GenChunk(getChunkAbs(), getChunkWrapper());
-        if (result != null) {
-            for (int i = 0; i < result.length; i++) {
-                short[] matrix = result[i];
+    public PlotBlock getBlock(int x, int y, int z) {
+        int i = MainUtil.CACHE_I[y][x][z];
+        if (result == null) {
+            MaterialData md = cd.getTypeAndData(x, y, z);
+            return PlotBlock.get(md.getItemTypeId(), md.getData());
+        }
+        short[] array = result[i];
+        if (array == null) {
+            return PlotBlock.get(0, 0);
+        }
+        int j = MainUtil.CACHE_J[y][x][z];
+        short id = array[j];
+        if (id == 0) {
+            return PlotBlock.get(id, 0);
+        }
+        byte[] dataArray = result_data[i];
+        if (dataArray == null) {
+            return PlotBlock.get(id, 0);
+        }
+        return PlotBlock.get(id, dataArray[j]);
+    }
+
+    public int getX() {
+        return chunk == null ? cx : chunk.getX();
+    }
+
+    public int getZ() {
+        return chunk == null ? cz : chunk.getZ();
+    }
+
+    @Override
+    public String getWorld() {
+        return chunk == null ? world : chunk.getWorld().getName();
+    }
+
+    @Override
+    public Location getMax() {
+        return new Location(getWorld(), 15 + (getX() << 4), 255, 15 + (getZ() << 4));
+    }
+
+    @Override
+    public Location getMin() {
+        return new Location(getWorld(), getX() << 4, 0, getZ() << 4);
+    }
+
+
+
+    public GenChunk clone() {
+        GenChunk toReturn = new GenChunk(chunk, new ChunkWrapper(getWorld(), chunk.getX(), chunk.getZ()));
+        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 < result_data.length; i++) {
-                byte[] matrix = result_data[i];
+            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 = cd;
+        toReturn.cd = this.cd;
         return toReturn;
     }
 
-    @Override
-    public PlotChunk shallowClone() {
-        GenChunk toReturn = new GenChunk(getChunkAbs(), getChunkWrapper());
-        toReturn.result = result;
-        toReturn.result_data = result_data;
-        toReturn.cd = cd;
+    public GenChunk shallowClone() {
+        GenChunk toReturn = new GenChunk(chunk, new ChunkWrapper(getWorld(), chunk.getX(), chunk.getZ()));
+        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

@@ -1,59 +0,0 @@
-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 (biomes == null) {
-            biomes = new int[16][16];
-        }
-        biomes[x][z] = biome;
-    }
-
-    @Override
-    public void setBlock(int x, int y, int z, int id, byte data) {
-        if (result[y >> 4] == null) {
-            result[y >> 4] = new PlotBlock[4096];
-        }
-        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 < result.length; i++) {
-            PlotBlock[] matrix = 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 = result;
-        return toReturn;
-    }
-}

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

@@ -1,281 +0,0 @@
-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 org.bukkit.Chunk;
-import org.bukkit.block.Biome;
-import org.bukkit.block.Block;
-
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.Map.Entry;
-import java.util.concurrent.ConcurrentHashMap;
-
-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;
-        }
-        final ChunkWrapper wrap = SetQueue.IMP.new ChunkWrapper(world, x >> 4, z >> 4);
-        x = x & 15;
-        z = z & 15;
-        PlotChunk<Chunk> result = blocks.get(wrap);
-        if (result == null) {
-            result = getChunk(wrap);
-            result.setBlock(x, y, z, id, data);
-            final PlotChunk<Chunk> previous = blocks.put(wrap, result);
-            if (previous == null) {
-                return true;
-            }
-            blocks.put(wrap, previous);
-            result = previous;
-        }
-        result.setBlock(x, y, z, id, data);
-        return true;
-    }
-
-    @Override
-    public void setChunk(PlotChunk<Chunk> chunk) {
-        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 (blocks.isEmpty()) {
-                return null;
-            }
-            final Iterator<Entry<ChunkWrapper, PlotChunk<Chunk>>> iter = blocks.entrySet().iterator();
-            final PlotChunk<Chunk> toReturn = iter.next().getValue();
-            if (SetQueue.IMP.isWaiting()) {
-                return null;
-            }
-            iter.remove();
-            execute(toReturn);
-            fixLighting(toReturn, true);
-            return toReturn;
-        } catch (final 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 (blocks.isEmpty()) {
-                return null;
-            }
-            final PlotChunk<Chunk> toReturn = blocks.remove(wrap);
-            if (toReturn == null) {
-                return null;
-            }
-            execute(toReturn);
-            fixLighting(toReturn, fixLighting);
-            return toReturn;
-        } catch (final Throwable e) {
-            e.printStackTrace();
-            return null;
-        }
-    }
-
-    @Override
-    public void clear() {
-        blocks.clear();
-    }
-
-    /**
-     * This should be overriden by any specialized queues 
-     * @param pc
-     */
-    public void execute(PlotChunk<Chunk> pc) {
-        SlowChunk sc = (SlowChunk) pc;
-        Chunk chunk = pc.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++) {
-                final int x = MainUtil.x_loc[i][j];
-                final int y = MainUtil.y_loc[i][j];
-                final 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 overriden by any specialized queues 
-     * @param wrap
-     */
-    @Override
-    public PlotChunk<Chunk> getChunk(ChunkWrapper wrap) {
-        return new SlowChunk(wrap);
-    }
-
-    /**
-     * This should be overriden by any specialized queues 
-     * @param fixAll
-     */
-    @Override
-    public boolean fixLighting(PlotChunk<Chunk> chunk, boolean fixAll) {
-        // Do nothing
-        return true;
-    }
-
-    /**
-     * This should be overriden by any specialized queues 
-     * @param locs
-     */
-    @Override
-    public void sendChunk(String world, Collection<ChunkLoc> locs) {
-        // Do nothing
-    }
-}

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

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

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

@@ -1,47 +1,47 @@
 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() {
-        final OfflinePlayer[] ops = Bukkit.getOfflinePlayers();
-        final BukkitOfflinePlayer[] toReturn = new BukkitOfflinePlayer[ops.length];
+        OfflinePlayer[] ops = Bukkit.getOfflinePlayers();
+        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,24 +1,22 @@
 package com.plotsquared.bukkit.uuid;
 
 import com.google.common.collect.HashBiMap;
+import com.google.common.collect.Sets;
 import com.google.common.io.ByteSource;
-import com.google.common.io.InputSupplier;
 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.object.OfflinePlotPlayer;
 import com.intellectualcrafters.plot.object.RunnableVal;
 import com.intellectualcrafters.plot.object.StringWrapper;
-import com.intellectualcrafters.plot.util.*;
+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.expiry.ExpireManager;
 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;
@@ -26,21 +24,23 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.UUID;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
 
 public class FileUUIDHandler extends UUIDHandlerImplementation {
-    
-    public FileUUIDHandler(final UUIDWrapper wrapper) {
+
+    public FileUUIDHandler(UUIDWrapper wrapper) {
         super(wrapper);
     }
-    
+
     @Override
-    public boolean startCaching(final Runnable whenDone) {
+    public boolean startCaching(Runnable whenDone) {
         return super.startCaching(whenDone) && cache(whenDone);
     }
-    
+
     public boolean cache(final Runnable whenDone) {
         final File container = Bukkit.getWorldContainer();
-        final List<World> worlds = Bukkit.getWorlds();
+        List<World> worlds = Bukkit.getWorlds();
         final String world;
         if (worlds.isEmpty()) {
             world = "world";
@@ -50,11 +50,11 @@ public class FileUUIDHandler extends UUIDHandlerImplementation {
         TaskManager.runTaskAsync(new Runnable() {
             @Override
             public void run() {
-                PS.debug(C.PREFIX.s() + "&6Starting player data caching for: " + world);
-                final File uuidfile = new File(PS.get().IMP.getDirectory(), "uuids.txt");
-                if (uuidfile.exists()) {
+                PS.debug(C.PREFIX + "&6Starting player data caching for: " + world);
+                File uuidFile = new File(PS.get().IMP.getDirectory(), "uuids.txt");
+                if (uuidFile.exists()) {
                     try {
-                        final List<String> lines = Files.readAllLines(uuidfile.toPath(), StandardCharsets.UTF_8);
+                        List<String> lines = Files.readAllLines(uuidFile.toPath(), StandardCharsets.UTF_8);
                         for (String line : lines) {
                             try {
                                 line = line.trim();
@@ -62,57 +62,55 @@ public class FileUUIDHandler extends UUIDHandlerImplementation {
                                     continue;
                                 }
                                 line = line.replaceAll("[\\|][0-9]+[\\|][0-9]+[\\|]", "");
-                                final String[] split = line.split("\\|");
-                                final String name = split[0];
-                                if ((name.isEmpty()) || (name.length() > 16) || !StringMan.isAlphanumericUnd(name)) {
+                                String[] split = line.split("\\|");
+                                String name = split[0];
+                                if (name.isEmpty() || (name.length() > 16) || !StringMan.isAlphanumericUnd(name)) {
                                     continue;
                                 }
-                                final UUID uuid = uuidWrapper.getUUID(name);
+                                UUID uuid = FileUUIDHandler.this.uuidWrapper.getUUID(name);
                                 if (uuid == null) {
                                     continue;
                                 }
                                 UUIDHandler.add(new StringWrapper(name), uuid);
-                            } catch (final Exception e2) {
+                            } catch (Exception e2) {
                                 e2.printStackTrace();
                             }
                         }
-                    } catch (final IOException e) {
+                    } catch (IOException e) {
                         e.printStackTrace();
                     }
                 }
-                if (Settings.TWIN_MODE_UUID) {
-                    final HashBiMap<StringWrapper, UUID> toAdd = HashBiMap.create(new HashMap<StringWrapper, UUID>());
-                    toAdd.put(new StringWrapper("*"), DBFunc.everyone);
-                    final HashSet<UUID> all = UUIDHandler.getAllUUIDS();
+                if (Settings.UUID.NATIVE_UUID_PROVIDER) {
+                    HashBiMap<StringWrapper, UUID> toAdd = HashBiMap.create(new HashMap<StringWrapper, UUID>());
+                    HashSet<UUID> all = UUIDHandler.getAllUUIDS();
                     PS.debug("&aFast mode UUID caching enabled!");
-                    final File playerdataFolder = new File(container, world + File.separator + "playerdata");
-                    final String[] dat = playerdataFolder.list(new FilenameFilter() {
-                        @Override
-                        public boolean accept(final File f, final String s) {
-                            return s.endsWith(".dat");
-                        }
-                    });
-                    final boolean check = all.isEmpty();
+                    File playerDataFolder = new File(container, world + File.separator + "playerdata");
+                    String[] dat = playerDataFolder.list(new DatFileFilter());
+                    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 {
-                                final UUID uuid = UUID.fromString(s);
+                                UUID uuid = UUID.fromString(s);
                                 if (check || all.remove(uuid)) {
-                                    final File file = new File(playerdataFolder + File.separator + current);
-                                    final InputSupplier<FileInputStream> is = com.google.common.io.Files.newInputStreamSupplier(file);
-                                    final NbtFactory.NbtCompound compound = NbtFactory.fromStream(is, NbtFactory.StreamOptions.GZIP_COMPRESSION);
-                                    final NbtFactory.NbtCompound bukkit = (NbtFactory.NbtCompound) compound.get("bukkit");
-                                    final String name = (String) bukkit.get("lastKnownName");
-                                    final long last = (long) bukkit.get("lastPlayed");
-                                    if (ExpireManager.IMP != null) {
-                                        ExpireManager.IMP.storeDate(uuid, last);
+                                    File file = new File(playerDataFolder, current);
+                                    ByteSource is = com.google.common.io.Files.asByteSource(file);
+                                    NbtFactory.NbtCompound compound = NbtFactory.fromStream(is, NbtFactory.StreamOptions.GZIP_COMPRESSION);
+                                    if (!compound.containsKey("bukkit")) {
+                                        PS.debug("ERROR: Player data does not contain the the key \"bukkit\"");
+                                    } else {
+                                        NbtFactory.NbtCompound bukkit = (NbtFactory.NbtCompound) compound.get("bukkit");
+                                        String name = (String) bukkit.get("lastKnownName");
+                                        long last = (long) bukkit.get("lastPlayed");
+                                        if (ExpireManager.IMP != null) {
+                                            ExpireManager.IMP.storeDate(uuid, last);
+                                        }
+                                        toAdd.put(new StringWrapper(name), uuid);
                                     }
-                                    toAdd.put(new StringWrapper(name), uuid);
                                 }
-                            } catch (final Exception e) {
+                            } catch (IOException e) {
                                 e.printStackTrace();
-                                PS.debug(C.PREFIX.s() + "Invalid playerdata: " + current);
+                                PS.debug(C.PREFIX + "Invalid playerdata: " + current);
                             }
                         }
                     }
@@ -126,45 +124,32 @@ public class FileUUIDHandler extends UUIDHandlerImplementation {
                         PS.debug("Failed to cache: " + all.size() + " uuids - slowly processing all files");
                     }
                 }
-                final HashBiMap<StringWrapper, UUID> toAdd = HashBiMap.create(new HashMap<StringWrapper, UUID>());
-                toAdd.put(new StringWrapper("*"), DBFunc.everyone);
-                final 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) {
+                HashBiMap<StringWrapper, UUID> toAdd = HashBiMap.create(new HashMap<StringWrapper, UUID>());
+                HashSet<String> worlds = Sets.newHashSet(world, "world");
+                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() {
-                        @Override
-                        public boolean accept(final File f, final String s) {
-                            return s.endsWith(".dat");
-                        }
-                    });
+                    playerDataFolder = new File(container, worldName + File.separator + "playerdata");
+                    String[] dat = playerDataFolder.list(new DatFileFilter());
                     if ((dat != null) && (dat.length != 0)) {
-                        for (final String current : dat) {
-                            final String s = current.replaceAll(".dat$", "");
+                        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 ignored) {
+                                PS.debug(C.PREFIX + "Invalid PlayerData: " + current);
                             }
                         }
                         break;
                     }
                     // Getting names
-                    final File playersFolder = new File(worldname + File.separator + "players");
-                    dat = playersFolder.list(new FilenameFilter() {
-                        @Override
-                        public boolean accept(final File f, final String s) {
-                            return s.endsWith(".dat");
-                        }
-                    });
+                    File playersFolder = new File(worldName + File.separator + "players");
+                    dat = playersFolder.list(new DatFileFilter());
                     if ((dat != null) && (dat.length != 0)) {
-                        for (final String current : dat) {
+                        for (String current : dat) {
                             names.add(current.replaceAll(".dat$", ""));
                         }
                         break;
@@ -172,45 +157,49 @@ public class FileUUIDHandler extends UUIDHandlerImplementation {
                 }
                 for (UUID uuid : uuids) {
                     try {
-                        final File file = new File(playerdataFolder + File.separator + uuid.toString() + ".dat");
+                        File file = new File(playerDataFolder + File.separator + uuid.toString() + ".dat");
                         if (!file.exists()) {
                             continue;
                         }
-                        final ByteSource is = com.google.common.io.Files.asByteSource(file);
-                        final NbtFactory.NbtCompound compound = NbtFactory.fromStream(is, NbtFactory.StreamOptions.GZIP_COMPRESSION);
-                        final NbtFactory.NbtCompound bukkit = (NbtFactory.NbtCompound) compound.get("bukkit");
-                        final String name = (String) bukkit.get("lastKnownName");
-                        final long last = (long) bukkit.get("lastPlayed");
-                        if (Settings.OFFLINE_MODE) {
-                            if (Settings.UUID_LOWERCASE && !name.toLowerCase().equals(name)) {
-                                uuid = uuidWrapper.getUUID(name);
-                            } else {
-                                final long most = (long) compound.get("UUIDMost");
-                                final long least = (long) compound.get("UUIDLeast");
-                                uuid = new UUID(most, least);
+                        ByteSource is = com.google.common.io.Files.asByteSource(file);
+                        NbtFactory.NbtCompound compound = NbtFactory.fromStream(is, NbtFactory.StreamOptions.GZIP_COMPRESSION);
+                        if (!compound.containsKey("bukkit")) {
+                            PS.debug("ERROR: Player data does not contain the the key \"bukkit\"");
+                        } else {
+                            NbtFactory.NbtCompound bukkit = (NbtFactory.NbtCompound) compound.get("bukkit");
+                            String name = (String) bukkit.get("lastKnownName");
+                            long last = (long) bukkit.get("lastPlayed");
+                            if (Settings.UUID.OFFLINE) {
+                                if (Settings.UUID.FORCE_LOWERCASE && !name.toLowerCase().equals(name)) {
+                                    uuid = FileUUIDHandler.this.uuidWrapper.getUUID(name);
+                                } else {
+                                    long most = (long) compound.get("UUIDMost");
+                                    long least = (long) compound.get("UUIDLeast");
+                                    uuid = new UUID(most, least);
+                                }
                             }
+                            if (ExpireManager.IMP != null) {
+                                ExpireManager.IMP.storeDate(uuid, last);
+                            }
+                            toAdd.put(new StringWrapper(name), uuid);
                         }
-                        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 (Exception ignored) {
+                        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().isEmpty()) {
-                    for (final OfflinePlotPlayer op : uuidWrapper.getOfflinePlayers()) {
-                        final long last = op.getLastPlayed();
+                    for (OfflinePlotPlayer op : FileUUIDHandler.this.uuidWrapper.getOfflinePlayers()) {
+                        long last = op.getLastPlayed();
                         if (last != 0) {
-                            final String name = op.getName();
-                            final StringWrapper wrap = new StringWrapper(name);
-                            final UUID uuid = uuidWrapper.getUUID(op);
+                            String name = op.getName();
+                            StringWrapper wrap = new StringWrapper(name);
+                            UUID uuid = FileUUIDHandler.this.uuidWrapper.getUUID(op);
                             toAdd.put(wrap, uuid);
                             if (ExpireManager.IMP != null) {
                                 ExpireManager.IMP.storeDate(uuid, last);
@@ -226,13 +215,13 @@ public class FileUUIDHandler extends UUIDHandlerImplementation {
         });
         return true;
     }
-    
+
     @Override
     public void fetchUUID(final String name, final RunnableVal<UUID> ifFetch) {
         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

@@ -1,108 +1,32 @@
 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;
 import com.intellectualcrafters.plot.object.OfflinePlotPlayer;
 import com.intellectualcrafters.plot.object.PlotPlayer;
-import com.intellectualcrafters.plot.object.StringWrapper;
-import com.intellectualcrafters.plot.util.UUIDHandler;
-import com.plotsquared.bukkit.object.BukkitOfflinePlayer;
+import org.bukkit.OfflinePlayer;
+
+import java.util.UUID;
 
 public class LowerOfflineUUIDWrapper extends OfflineUUIDWrapper {
-    private Method getOnline = null;
-    private final Object[] arg = new Object[0];
-    
-    public LowerOfflineUUIDWrapper() {
-        try {
-            getOnline = Server.class.getMethod("getOnlinePlayers");
-        } catch (final NoSuchMethodException | SecurityException e) {
-            e.printStackTrace();
-        }
-    }
-    
+
     @Override
-    public UUID getUUID(final PlotPlayer player) {
+    public UUID getUUID(PlotPlayer player) {
         return UUID.nameUUIDFromBytes(("OfflinePlayer:" + player.getName().toLowerCase()).getBytes(Charsets.UTF_8));
     }
-    
+
     @Override
-    public UUID getUUID(final OfflinePlotPlayer player) {
+    public UUID getUUID(OfflinePlotPlayer player) {
         return UUID.nameUUIDFromBytes(("OfflinePlayer:" + player.getName().toLowerCase()).getBytes(Charsets.UTF_8));
     }
-    
+
     @Override
-    public UUID getUUID(final OfflinePlayer player) {
+    public UUID getUUID(OfflinePlayer player) {
         return UUID.nameUUIDFromBytes(("OfflinePlayer:" + player.getName().toLowerCase()).getBytes(Charsets.UTF_8));
     }
-    
+
     @Override
-    public OfflinePlotPlayer getOfflinePlayer(final UUID uuid) {
-        final BiMap<UUID, StringWrapper> map = UUIDHandler.getUuidMap().inverse();
-        String name;
-        try {
-            name = map.get(uuid).value;
-        } catch (final NullPointerException e) {
-            name = null;
-        }
-        if (name != null) {
-            final OfflinePlayer op = Bukkit.getOfflinePlayer(name);
-            if (op.hasPlayedBefore()) {
-                return new BukkitOfflinePlayer(op);
-            }
-        }
-        for (final OfflinePlayer player : Bukkit.getOfflinePlayers()) {
-            if (getUUID(player).equals(uuid)) {
-                return new BukkitOfflinePlayer(player);
-            }
-        }
-        return null;
-    }
-    
-    @Override
-    public Player[] getOnlinePlayers() {
-        if (getOnline == null) {
-            Collection<? extends Player> onlinePlayers = Bukkit.getOnlinePlayers();
-            return onlinePlayers.toArray(new Player[onlinePlayers.size()]);
-        }
-        try {
-            final Object players = getOnline.invoke(Bukkit.getServer(), 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[p.size()]);
-            }
-        } catch (final Exception e) {
-            PS.debug("Failed to resolve online players");
-            getOnline = null;
-            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.toLowerCase()).getBytes(Charsets.UTF_8));
     }
-    
-    @Override
-    public OfflinePlotPlayer[] getOfflinePlayers() {
-        final OfflinePlayer[] ops = Bukkit.getOfflinePlayers();
-        final BukkitOfflinePlayer[] toReturn = new BukkitOfflinePlayer[ops.length];
-        for (int i = 0; i < ops.length; i++) {
-            toReturn[i] = new BukkitOfflinePlayer(ops[i]);
-        }
-        return toReturn;
-    }
+
 }

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,93 +9,100 @@ 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.InvocationTargetException;
+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 {
-            getOnline = Server.class.getMethod("getOnlinePlayers");
-        } catch (final NoSuchMethodException | 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();
-        String name;
-        try {
+    public OfflinePlotPlayer getOfflinePlayer(UUID uuid) {
+        BiMap<UUID, StringWrapper> map = UUIDHandler.getUuidMap().inverse();
+        String name = null;
+        if (map.containsKey(uuid)) {
             name = map.get(uuid).value;
-        } catch (final 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);
             }
         }
         return null;
     }
-    
+
     public Player[] getOnlinePlayers() {
-        if (getOnline == null) {
+        if (this.getOnline == null) {
             Collection<? extends Player> onlinePlayers = Bukkit.getOnlinePlayers();
             return onlinePlayers.toArray(new Player[onlinePlayers.size()]);
         }
         try {
-            final Object players = getOnline.invoke(Bukkit.getServer(), 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;
+                @SuppressWarnings("unchecked") Collection<? extends Player> p = (Collection<? extends Player>) players;
                 return p.toArray(new Player[p.size()]);
             }
-        } catch (final Exception e) {
+        } catch (IllegalAccessException | InvocationTargetException | IllegalArgumentException ignored) {
             PS.debug("Failed to resolve online players");
-            getOnline = null;
+            this.getOnline = null;
             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() {
-        final OfflinePlayer[] ops = Bukkit.getOfflinePlayers();
-        final BukkitOfflinePlayer[] toReturn = new BukkitOfflinePlayer[ops.length];
+        OfflinePlayer[] ops = Bukkit.getOfflinePlayers();
+        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

@@ -1,5 +1,18 @@
 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.SQLite;
+import com.intellectualcrafters.plot.object.RunnableVal;
+import com.intellectualcrafters.plot.object.StringWrapper;
+import com.intellectualcrafters.plot.util.MainUtil;
+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 java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.net.HttpURLConnection;
@@ -12,58 +25,44 @@ import java.util.ArrayDeque;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.UUID;
-
 import org.json.simple.JSONArray;
 import org.json.simple.JSONObject;
 import org.json.simple.parser.JSONParser;
-
-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.parser.ParseException;
 
 public class SQLUUIDHandler extends UUIDHandlerImplementation {
-    
-    final String PROFILE_URL = "https://sessionserver.mojang.com/session/minecraft/profile/";
-    final int MAX_REQUESTS = 500;
-    final int INTERVAL = 12000;
-    final JSONParser jsonParser = new JSONParser();
-    private final SQLite _sqLite;
 
-    public SQLUUIDHandler(final UUIDWrapper wrapper) {
+    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);
-        _sqLite = new SQLite("./plugins/PlotSquared/usercache.db");
+        this.sqlite = new SQLite(MainUtil.getFile(PS.get().IMP.getDirectory(), "usercache.db"));
         try {
-            _sqLite.openConnection();
-        } catch (final Exception e) {
+            this.sqlite.openConnection();
+        } catch (ClassNotFoundException | SQLException e) {
             e.printStackTrace();
         }
 
-        try {
-            final PreparedStatement stmt = getConnection().prepareStatement(
-            "CREATE TABLE IF NOT EXISTS `usercache` (uuid VARCHAR(32) NOT NULL, username VARCHAR(32) NOT NULL, PRIMARY KEY (uuid, username))");
+        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();
-            stmt.close();
-        } catch (final SQLException e) {
+        } catch (SQLException e) {
             e.printStackTrace();
         }
         startCaching(null);
     }
-    
+
     private Connection getConnection() {
-        synchronized (_sqLite) {
-            return _sqLite.getConnection();
+        synchronized (this.sqlite) {
+            return this.sqlite.getConnection();
         }
     }
-    
+
     @Override
     public boolean startCaching(final Runnable whenDone) {
         if (!super.startCaching(whenDone)) {
@@ -73,23 +72,19 @@ public class SQLUUIDHandler extends UUIDHandlerImplementation {
             @Override
             public void run() {
                 try {
-                    final HashBiMap<StringWrapper, UUID> toAdd = HashBiMap.create(new HashMap<StringWrapper, UUID>());
-                    final PreparedStatement statement = getConnection().prepareStatement("SELECT `uuid`, `username` FROM `usercache`");
-                    final ResultSet resultSet = statement.executeQuery();
-                    StringWrapper username;
-                    UUID uuid;
-                    while (resultSet.next()) {
-                        username = new StringWrapper(resultSet.getString("username"));
-                        uuid = UUID.fromString(resultSet.getString("uuid"));
-                        toAdd.put(new StringWrapper(username.value), uuid);
+                    HashBiMap<StringWrapper, UUID> toAdd = HashBiMap.create(new HashMap<StringWrapper, UUID>());
+                    try (PreparedStatement statement = getConnection().prepareStatement("SELECT `uuid`, `username` FROM `usercache`");
+                            ResultSet resultSet = statement.executeQuery()) {
+                        while (resultSet.next()) {
+                            StringWrapper username = new StringWrapper(resultSet.getString("username"));
+                            UUID uuid = UUID.fromString(resultSet.getString("uuid"));
+                            toAdd.put(new StringWrapper(username.value), uuid);
+                        }
                     }
-                    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 (final UUID u : UUIDHandler.getAllUUIDS()) {
+                    for (UUID u : UUIDHandler.getAllUUIDS()) {
                         if (!uuidExists(u)) {
                             toFetch.add(u);
                         }
@@ -100,13 +95,13 @@ public class SQLUUIDHandler extends UUIDHandlerImplementation {
                         }
                         return;
                     }
-                    final FileUUIDHandler fileHandler = new FileUUIDHandler(SQLUUIDHandler.this.uuidWrapper);
+                    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 (Settings.UUID.OFFLINE) {
                                 if (whenDone != null) {
                                     whenDone.run();
                                 }
@@ -125,80 +120,35 @@ public class SQLUUIDHandler extends UUIDHandlerImplementation {
                                         }
                                         for (int i = 0; i < Math.min(500, toFetch.size()); i++) {
                                             UUID uuid = toFetch.pop();
-                                            HttpURLConnection connection = (HttpURLConnection) new URL(PROFILE_URL + uuid.toString().replace("-", "")).openConnection();
+                                            HttpURLConnection connection =
+                                                    (HttpURLConnection) new URL(SQLUUIDHandler.this.PROFILE_URL + uuid.toString().replace("-", ""))
+                                                            .openConnection();
                                             InputStreamReader reader = new InputStreamReader(connection.getInputStream());
-                                            JSONObject response = (JSONObject) jsonParser.parse(reader);
+                                            JSONObject response = (JSONObject) SQLUUIDHandler.this.jsonParser.parse(reader);
                                             String name = (String) response.get("name");
                                             if (name != null) {
                                                 add(new StringWrapper(name), uuid);
                                             }
                                         }
-                                    } catch (Exception e) {
+                                    } catch (IOException | ParseException e) {
                                         e.printStackTrace();
                                     }
-                                    TaskManager.runTaskLaterAsync(this, INTERVAL);
+                                    TaskManager.runTaskLaterAsync(this, SQLUUIDHandler.this.INTERVAL);
                                 }
                             });
-                            /*
-                             * This API is no longer accessible.
-                             */
-                            //                            if (!Settings.OFFLINE_MODE) {
-                            //                                PS.debug(C.PREFIX.s() + "&cWill fetch &6" + toFetch.size() + "&c from mojang!");
-                            //
-                            //                                int i = 0;
-                            //                                final Iterator<UUID> iterator = toFetch.iterator();
-                            //                                while (iterator.hasNext()) {
-                            //                                    final StringBuilder url = new StringBuilder("http://api.intellectualsites.com/uuid/?user=");
-                            //                                    final List<UUID> currentIteration = new ArrayList<>();
-                            //                                    while ((i++ <= 15) && iterator.hasNext()) {
-                            //                                        final UUID _uuid = iterator.next();
-                            //                                        url.append(_uuid.toString());
-                            //                                        if (iterator.hasNext()) {
-                            //                                            url.append(",");
-                            //                                        }
-                            //                                        currentIteration.add(_uuid);
-                            //                                    }
-                            //                                    PS.debug(C.PREFIX.s() + "&cWill attempt to fetch &6" + currentIteration.size() + "&c uuids from: &6" + url.toString());
-                            //                                    try {
-                            //                                        final HttpURLConnection connection = (HttpURLConnection) new URL(url.toString()).openConnection();
-                            //                                        connection.setRequestProperty("User-Agent", "Mozilla/5.0");
-                            //                                        final BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
-                            //                                        String line;
-                            //                                        final StringBuilder rawJSON = new StringBuilder();
-                            //                                        while ((line = reader.readLine()) != null) {
-                            //                                            rawJSON.append(line);
-                            //                                        }
-                            //                                        reader.close();
-                            //                                        final JSONObject object = new JSONObject(rawJSON.toString());
-                            //                                        for (final UUID _u : currentIteration) {
-                            //                                            final Object o = object.getJSONObject(_u.toString().replace("-", "")).get("username");
-                            //                                            if ((o == null) || !(o instanceof String)) {
-                            //                                                continue;
-                            //                                            }
-                            //                                            add(new StringWrapper(o.toString()), _u);
-                            //                                        }
-                            //                                    } catch (final Exception e) {
-                            //                                        e.printStackTrace();
-                            //                                    }
-                            //                                    i = 0;
-                            //                                }
-                            //                            }
-                            //                            if (whenDone != null) {
-                            //                                whenDone.run();
-                            //                            }
                         }
                     });
-                } catch (final SQLException e) {
+                } 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.s() + "UUID for '" + name + "' was null. We'll cache this from the mojang servers!");
+        PS.debug(C.PREFIX + "UUID for '" + name + "' was null. We'll cache this from the Mojang servers!");
         if (ifFetch == null) {
             return;
         }
@@ -206,7 +156,7 @@ public class SQLUUIDHandler extends UUIDHandlerImplementation {
             @Override
             public void run() {
                 try {
-                    URL url = new URL(PROFILE_URL);
+                    URL url = new URL(SQLUUIDHandler.this.PROFILE_URL);
                     HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                     connection.setRequestMethod("POST");
                     connection.setRequestProperty("Content-Type", "application/json");
@@ -218,29 +168,31 @@ public class SQLUUIDHandler extends UUIDHandlerImplementation {
                     stream.write(body.getBytes());
                     stream.flush();
                     stream.close();
-                    JSONArray array = (JSONArray) jsonParser.parse(new InputStreamReader(connection.getInputStream()));
+                    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 (Exception e) {
+                    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 (final SQLException e) {
+        } catch (SQLException e) {
             throw new SQLUUIDHandlerException("Couldn't close database connection", e);
         }
     }
-    
+
     @Override
     public boolean add(final StringWrapper name, final UUID uuid) {
         // Ignoring duplicates
@@ -248,13 +200,12 @@ public class SQLUUIDHandler extends UUIDHandlerImplementation {
             TaskManager.runTaskAsync(new Runnable() {
                 @Override
                 public void run() {
-                    try {
-                        final PreparedStatement statement = getConnection().prepareStatement("REPLACE INTO usercache (`uuid`, `username`) VALUES(?, ?)");
+                    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.s() + "&cAdded '&6" + uuid + "&c' - '&6" + name + "&c'");
-                    } catch (final SQLException e) {
+                        PS.debug(C.PREFIX + "&cAdded '&6" + uuid + "&c' - '&6" + name + "&c'");
+                    } catch (SQLException e) {
                         e.printStackTrace();
                     }
                 }
@@ -263,7 +214,7 @@ public class SQLUUIDHandler extends UUIDHandlerImplementation {
         }
         return false;
     }
-    
+
     /**
      * This is useful for name changes
      */
@@ -273,13 +224,12 @@ public class SQLUUIDHandler extends UUIDHandlerImplementation {
         TaskManager.runTaskAsync(new Runnable() {
             @Override
             public void run() {
-                try {
-                    final PreparedStatement statement = getConnection().prepareStatement("UPDATE usercache SET `username`=? WHERE `uuid`=?");
+                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.s() + "Name change for '" + uuid + "' to '" + name.value + "'");
-                } catch (final SQLException e) {
+                    PS.debug(C.PREFIX + "Name change for '" + uuid + "' to '" + name.value + '\'');
+                } catch (SQLException e) {
                     e.printStackTrace();
                 }
             }
@@ -288,7 +238,7 @@ public class SQLUUIDHandler extends UUIDHandlerImplementation {
 
     private class SQLUUIDHandlerException extends RuntimeException {
 
-        SQLUUIDHandlerException(final String s, final Throwable c) {
+        SQLUUIDHandlerException(String s, Throwable c) {
             super("SQLUUIDHandler caused an exception: " + s, c);
         }
     }