Several changes:

- Several API improvements
- persistent WorldEdit bypass toggle
- persistent plot chat toggle
- Plot BO3 exporting (useful f
- Fix fastmode clearing unclaim border
- Add player-interact flag for NPC interaction etc. Fixes #543
- Several fixes for sponge
- some code cleanup
- Closes #529

src/main/java/com/intellectualcrafters/plot/util/BO3Handler.java

@@ -0,0 +1,160 @@
+package com.intellectualcrafters.plot.util;
+
+import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.StandardOpenOption;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map.Entry;
+
+import com.intellectualcrafters.plot.PS;
+import com.intellectualcrafters.plot.config.Settings;
+import com.intellectualcrafters.plot.generator.ClassicPlotWorld;
+import com.intellectualcrafters.plot.object.BO3;
+import com.intellectualcrafters.plot.object.ChunkLoc;
+import com.intellectualcrafters.plot.object.Location;
+import com.intellectualcrafters.plot.object.Plot;
+import com.intellectualcrafters.plot.object.PlotBlock;
+import com.intellectualcrafters.plot.object.PlotPlayer;
+import com.intellectualcrafters.plot.object.PlotWorld;
+import com.intellectualcrafters.plot.util.SchematicHandler.Dimension;
+
+public class BO3Handler {
+    
+    /**
+     * @see #saveBO3(null, Plot)
+     * @param plot
+     * @return if successfully exported 
+     */
+    public static boolean saveBO3(Plot plot) {
+        return saveBO3(null, plot);
+    }
+    
+    /**
+     * Save a plot as a BO3 file<br>
+     *  - Use null for the player object if no player is applicable
+     * @param plr
+     * @param plot
+     * @return
+     */
+    public static boolean saveBO3(PlotPlayer plr, Plot plot) {
+        PlotWorld plotworld = PS.get().getPlotWorld(plot.world);
+        if (!(plotworld instanceof ClassicPlotWorld) || plotworld.TYPE != 0) {
+            MainUtil.sendMessage(plr, "BO3 exporting only supports type 0 classic generation.");
+            return false;
+        }
+        String alias = plot.toString();
+        Location pos1 = plot.getBottom().add(1, 0, 1);
+        Location pos2 = plot.getTop();
+        ClassicPlotWorld cpw = (ClassicPlotWorld) plotworld;
+        int height = cpw.PLOT_HEIGHT;
+        
+        int cx = (pos1.getX() + pos2.getX()) / 2;
+        int cz = (pos1.getZ() + pos2.getZ()) / 2;
+        
+        HashMap<ChunkLoc, BO3> map = new HashMap<>();
+        
+        boolean content = false;
+        for (int x = pos1.getX(); x <= pos2.getX(); x++) {
+            int X = ((x + 7) - cx) >> 4;
+            int xx = (x - cx) % 16;
+            for (int z = pos1.getZ(); z <= pos2.getZ(); z++) {
+                int Z = ((z + 7) - cz) >> 4;
+                int zz = (z - cz) % 16;
+                ChunkLoc loc = new ChunkLoc(X, Z);
+                BO3 bo3 = map.get(loc);
+                for (int y = height + 1; y < 256; y++) {
+                    PlotBlock block = BlockManager.manager.getBlock(new Location(plot.world, x, y, z));
+                    if (block != null && block.id != 0) {
+                        if (bo3 == null) {
+                            bo3 = new BO3(alias, loc);
+                            map.put(loc, bo3);
+                            content = true;
+                        }
+                        bo3.addBlock(xx, y - height - 1, zz, block);
+                    }
+                }
+            }
+        }
+        
+        if (!content) {
+            MainUtil.sendMessage(plr, "No content found!");
+            return false;
+        }
+        
+        for (Entry<ChunkLoc, BO3> entry : map.entrySet()) {
+            ChunkLoc chunk = entry.getKey();
+            BO3 bo3 = entry.getValue();
+            if (chunk.x == 0 && chunk.z == 0) {
+                continue;
+            }
+            int x = chunk.x;
+            int z = chunk.z;
+            if (Math.abs(chunk.x) > Math.abs(chunk.z)) {
+                x += chunk.x > 0 ? -1 : 1;
+            }
+            else {
+                z += chunk.z > 0 ? -1 : 1;
+            }
+            ChunkLoc parentLoc = new ChunkLoc(x, z);
+            if (!map.containsKey(parentLoc)) {
+                parentLoc = null;
+                for (Entry<ChunkLoc, BO3> entry2 : map.entrySet()) {
+                    ChunkLoc other = entry2.getKey();
+                    if ((other.x == chunk.x - 1 && other.z == chunk.z) || (other.z == chunk.z - 1 && other.x == chunk.x)) {
+                        parentLoc = other;
+                    }
+                }
+                if (parentLoc == null) {
+                    MainUtil.sendMessage(plr, "Exporting BO3 cancelled due to detached chunk: " + chunk + " - Make sure you only have one object per plot");
+                    return false;
+                }
+            }
+            map.get(parentLoc).addChild(bo3);
+        }
+        
+        for (Entry<ChunkLoc, BO3> entry : map.entrySet()) {
+            save(plot, entry.getValue());
+        }
+        
+        MainUtil.sendMessage(plr, "BO3 exporting was successful!");
+        return true;
+    }
+    
+    public static boolean save(Plot plot, BO3 bo3) {
+        File base = getBaseFile(plot.world);
+        try {
+            List<String> lines = Files.readAllLines(base.toPath(), StandardCharsets.UTF_8);
+            for (int i = 0; i < lines.size(); i++) {
+                String line = lines.get(i).trim();
+                String result = StringMan.replaceAll(line, "%owner%", MainUtil.getName(plot.owner), "%alias%", plot.toString(), "%blocks%", bo3.getBlocks(), "%branches%", bo3.getChildren());
+                if (!StringMan.isEqual(result, line)) {
+                    lines.set(i, result);
+                }
+            }
+            File bo3File;
+            if (bo3.getLoc().x == 0 && bo3.getLoc().z == 0) {
+                bo3File = new File(base.getParentFile(), bo3.getName() + ".bo3");
+            }
+            else {
+                bo3File = new File(base.getParentFile(), bo3.getName() + "_" + bo3.getLoc().x + "_" + bo3.getLoc().z + ".bo3");
+            }
+            bo3File.createNewFile();
+            Files.write(bo3File.toPath(), StringMan.join(lines, System.getProperty("line.separator")).getBytes(), StandardOpenOption.WRITE);
+            return true;
+        }
+        catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+    
+    public static File getBaseFile(String category) {
+        File base = new File(PS.get().IMP.getDirectory(), Settings.BO3_SAVE_PATH + File.separator + category + File.separator + "base.yml");
+        if (!base.exists()) {
+            PS.get().copyFile("base.yml", Settings.BO3_SAVE_PATH + File.separator + category);
+        }
+        return base;
+    }
+}

src/main/java/com/intellectualcrafters/plot/util/EventUtil.java

@@ -5,6 +5,7 @@ import java.util.HashSet;
 import java.util.UUID;
 
 import com.intellectualcrafters.plot.PS;
+import com.intellectualcrafters.plot.config.C;
 import com.intellectualcrafters.plot.flag.Flag;
 import com.intellectualcrafters.plot.flag.FlagManager;
 import com.intellectualcrafters.plot.object.LazyBlock;
@@ -81,85 +82,85 @@ public abstract class EventUtil {
             }
             case BREAK_BLOCK: {
                 if (plot == null) {
-                    return Permissions.hasPermission(pp, Permissions.BREAK_ROAD.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_DESTROY_ROAD.s(), notifyPerms);
                 }
                 if (!plot.hasOwner()) {
-                    return Permissions.hasPermission(pp, Permissions.BREAK_UNOWNED.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_DESTROY_UNOWNED.s(), notifyPerms);
                 }
                 Flag flag = FlagManager.getPlotFlag(plot, "break");
                 HashSet<PlotBlock> value = flag == null ? null : (HashSet<PlotBlock>) flag.getValue();
                 if (value == null || (!value.contains(PlotBlock.EVERYTHING) && !value.contains(block.getPlotBlock()))) {
-                    return Permissions.hasPermission(pp, Permissions.BREAK_OTHER.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_DESTROY_OTHER.s(), notifyPerms);
                 }
                 return true;
             }
             case BREAK_HANGING:
                 if (plot == null) {
-                    return Permissions.hasPermission(pp, Permissions.BREAK_ROAD.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_DESTROY_ROAD.s(), notifyPerms);
                 }
                 if (FlagManager.isPlotFlagTrue(plot, "hanging-break")) {
                     return true;
                 }
                 if (plot.hasOwner()) {
-                    return Permissions.hasPermission(pp, Permissions.BREAK_OTHER.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_DESTROY_OTHER.s(), notifyPerms);
                 }
-                return Permissions.hasPermission(pp, Permissions.BREAK_UNOWNED.s, notifyPerms);
+                return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_DESTROY_UNOWNED.s(), notifyPerms);
             case BREAK_MISC:
                 if (plot == null) {
-                    return Permissions.hasPermission(pp, Permissions.BREAK_ROAD.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_DESTROY_ROAD.s(), notifyPerms);
                 }
                 if (FlagManager.isPlotFlagTrue(plot, "misc-break")) {
                     return true;
                 }
                 if (plot.hasOwner()) {
-                    return Permissions.hasPermission(pp, Permissions.BREAK_OTHER.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_DESTROY_OTHER.s(), notifyPerms);
                 }
-                return Permissions.hasPermission(pp, Permissions.BREAK_UNOWNED.s, notifyPerms);
+                return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_DESTROY_UNOWNED.s(), notifyPerms);
             case BREAK_VEHICLE:
                 if (plot == null) {
-                    return Permissions.hasPermission(pp, Permissions.BREAK_ROAD.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_DESTROY_ROAD.s(), notifyPerms);
                 }
                 if (FlagManager.isPlotFlagTrue(plot, "vehicle-break")) {
                     return true;
                 }
                 if (plot.hasOwner()) {
-                    return Permissions.hasPermission(pp, Permissions.BREAK_OTHER.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_DESTROY_OTHER.s(), notifyPerms);
                 }
-                return Permissions.hasPermission(pp, Permissions.BREAK_UNOWNED.s, notifyPerms);
+                return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_DESTROY_UNOWNED.s(), notifyPerms);
             case INTERACT_BLOCK: {
                 if (plot == null) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_ROAD.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_ROAD.s(), notifyPerms);
                 }
                 if (!plot.hasOwner()) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_UNOWNED.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_UNOWNED.s(), notifyPerms);
                 }
                 Flag flag = FlagManager.getPlotFlag(plot, "use");
                 HashSet<PlotBlock> value = flag == null ? null : (HashSet<PlotBlock>) flag.getValue();
                 if (value == null || (!value.contains(PlotBlock.EVERYTHING) && !value.contains(block.getPlotBlock()))) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_OTHER.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), notifyPerms);
                 }
                 return true;
             }
             case PLACE_BLOCK: {
                 if (plot == null) {
-                    return Permissions.hasPermission(pp, Permissions.BUILD_ROAD.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_BUILD_ROAD.s(), notifyPerms);
                 }
                 if (!plot.hasOwner()) {
-                    return Permissions.hasPermission(pp, Permissions.BUILD_UNOWNED.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_BUILD_UNOWNED.s(), notifyPerms);
                 }
                 Flag flag = FlagManager.getPlotFlag(plot, "place");
                 HashSet<PlotBlock> value = flag == null ? null : (HashSet<PlotBlock>) flag.getValue();
                 if (value == null || (!value.contains(PlotBlock.EVERYTHING) && !value.contains(block.getPlotBlock()))) {
-                    return Permissions.hasPermission(pp, Permissions.BUILD_OTHER.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_BUILD_OTHER.s(), notifyPerms);
                 }
                 return true;
             }
             case TRIGGER_PHYSICAL: {
                 if (plot == null) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_ROAD.s, false);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_ROAD.s(), false);
                 }
                 if (!plot.hasOwner()) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_UNOWNED.s, false);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_UNOWNED.s(), false);
                 }
                 if (FlagManager.isPlotFlagTrue(plot, "device-interact")) {
                     return true;
@@ -167,16 +168,16 @@ public abstract class EventUtil {
                 Flag flag = FlagManager.getPlotFlag(plot, "use");
                 HashSet<PlotBlock> value = flag == null ? null : (HashSet<PlotBlock>) flag.getValue();
                 if (value == null || (!value.contains(PlotBlock.EVERYTHING) && !value.contains(block.getPlotBlock()))) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_OTHER.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), notifyPerms);
                 }
                 return true;
             }
             case INTERACT_HANGING: {
                 if (plot == null) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_ROAD.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_ROAD.s(), notifyPerms);
                 }
                 if (!plot.hasOwner()) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_UNOWNED.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_UNOWNED.s(), notifyPerms);
                 }
                 if (FlagManager.isPlotFlagTrue(plot, "hanging-interact")) {
                     return true;
@@ -184,16 +185,16 @@ public abstract class EventUtil {
                 Flag flag = FlagManager.getPlotFlag(plot, "use");
                 HashSet<PlotBlock> value = flag == null ? null : (HashSet<PlotBlock>) flag.getValue();
                 if (value == null || (!value.contains(PlotBlock.EVERYTHING) && !value.contains(block.getPlotBlock()))) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_OTHER.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), notifyPerms);
                 }
                 return true;
             }
             case INTERACT_MISC: {
                 if (plot == null) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_ROAD.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_ROAD.s(), notifyPerms);
                 }
                 if (!plot.hasOwner()) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_UNOWNED.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_UNOWNED.s(), notifyPerms);
                 }
                 if (FlagManager.isPlotFlagTrue(plot, "misc-interact")) {
                     return true;
@@ -201,16 +202,16 @@ public abstract class EventUtil {
                 Flag flag = FlagManager.getPlotFlag(plot, "use");
                 HashSet<PlotBlock> value = flag == null ? null : (HashSet<PlotBlock>) flag.getValue();
                 if (value == null || (!value.contains(PlotBlock.EVERYTHING) && !value.contains(block.getPlotBlock()))) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_OTHER.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), notifyPerms);
                 }
                 return true;
             }
             case INTERACT_VEHICLE: {
                 if (plot == null) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_ROAD.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_ROAD.s(), notifyPerms);
                 }
                 if (!plot.hasOwner()) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_UNOWNED.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_UNOWNED.s(), notifyPerms);
                 }
                 if (FlagManager.isPlotFlagTrue(plot, "vehicle-use")) {
                     return true;
@@ -218,16 +219,16 @@ public abstract class EventUtil {
                 Flag flag = FlagManager.getPlotFlag(plot, "use");
                 HashSet<PlotBlock> value = flag == null ? null : (HashSet<PlotBlock>) flag.getValue();
                 if (value == null || (!value.contains(PlotBlock.EVERYTHING) && !value.contains(block.getPlotBlock()))) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_OTHER.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), notifyPerms);
                 }
                 return true;
             }
             case SPAWN_MOB: {
                 if (plot == null) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_OTHER.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), notifyPerms);
                 }
                 if (!plot.hasOwner()) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_UNOWNED.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_UNOWNED.s(), notifyPerms);
                 }
                 
                 if (FlagManager.isPlotFlagTrue(plot, "mob-place")) {
@@ -236,16 +237,16 @@ public abstract class EventUtil {
                 Flag flag = FlagManager.getPlotFlag(plot, "place");
                 HashSet<PlotBlock> value = flag == null ? null : (HashSet<PlotBlock>) flag.getValue();
                 if (value == null || (!value.contains(PlotBlock.EVERYTHING) && !value.contains(block.getPlotBlock()))) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_OTHER.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), notifyPerms);
                 }
                 return true;
             }
             case PLACE_HANGING: {
 //                if (plot == null) {
-//                    return Permissions.hasPermission(pp, Permissions.INTERACT_OTHER.s, notifyPerms);
+//                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), notifyPerms);
 //                }
 //                if (!plot.hasOwner()) {
-//                    return Permissions.hasPermission(pp, Permissions.INTERACT_UNOWNED.s, notifyPerms);
+//                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_UNOWNED.s(), notifyPerms);
 //                }
 //                
 //                if (FlagManager.isPlotFlagTrue(plot, "hanging-place")) {
@@ -254,16 +255,16 @@ public abstract class EventUtil {
 //                Flag flag = FlagManager.getPlotFlag(plot, "place");
 //                HashSet<PlotBlock> value = flag == null ? null : (HashSet<PlotBlock>) flag.getValue();
 //                if (value == null || (!value.contains(PlotBlock.EVERYTHING) && !value.contains(block.getPlotBlock()))) {
-//                    return Permissions.hasPermission(pp, Permissions.INTERACT_OTHER.s, notifyPerms);
+//                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), notifyPerms);
 //                }
                 return true;
             }
             case PLACE_MISC: {
                 if (plot == null) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_OTHER.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), notifyPerms);
                 }
                 if (!plot.hasOwner()) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_UNOWNED.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_UNOWNED.s(), notifyPerms);
                 }
                 
                 if (FlagManager.isPlotFlagTrue(plot, "misc-place")) {
@@ -272,16 +273,16 @@ public abstract class EventUtil {
                 Flag flag = FlagManager.getPlotFlag(plot, "place");
                 HashSet<PlotBlock> value = flag == null ? null : (HashSet<PlotBlock>) flag.getValue();
                 if (value == null || (!value.contains(PlotBlock.EVERYTHING) && !value.contains(block.getPlotBlock()))) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_OTHER.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), notifyPerms);
                 }
                 return true;
             }
             case PLACE_VEHICLE: {
                 if (plot == null) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_OTHER.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), notifyPerms);
                 }
                 if (!plot.hasOwner()) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_UNOWNED.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_UNOWNED.s(), notifyPerms);
                 }
                 
                 if (FlagManager.isPlotFlagTrue(plot, "vehicle-place")) {
@@ -290,7 +291,7 @@ public abstract class EventUtil {
                 Flag flag = FlagManager.getPlotFlag(plot, "place");
                 HashSet<PlotBlock> value = flag == null ? null : (HashSet<PlotBlock>) flag.getValue();
                 if (value == null || (!value.contains(PlotBlock.EVERYTHING) && !value.contains(block.getPlotBlock()))) {
-                    return Permissions.hasPermission(pp, Permissions.INTERACT_OTHER.s, notifyPerms);
+                    return Permissions.hasPermission(pp, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), notifyPerms);
                 }
                 return true;
             }

src/main/java/com/intellectualcrafters/plot/util/MainUtil.java

@@ -1033,25 +1033,30 @@ public class MainUtil {
         System.currentTimeMillis();
         final PlotWorld plotworld = PS.get().getPlotWorld(plot.world);
         runners.put(plot, 1);
-        if (plotworld.TERRAIN != 0 || Settings.FAST_CLEAR) {
-            final Location pos2 = MainUtil.getPlotTopLoc(plot.world, plot.id);
-            ChunkManager.manager.regenerateRegion(pos1, pos2, new Runnable() {
-                @Override
-                public void run() {
-                    runners.remove(plot);
-                    TaskManager.runTask(whenDone);
-                }
-            });
-            return;
-        }
         final Runnable run = new Runnable() {
             @Override
             public void run() {
-                runners.remove(plot);
-                TaskManager.runTask(whenDone);
+                if (isDelete) {
+                    manager.unclaimPlot(plotworld, plot, new Runnable() {
+                        @Override
+                        public void run() {
+                            runners.remove(plot);
+                            TaskManager.runTask(whenDone);
+                        }
+                    });
+                }
+                else {
+                    runners.remove(plot);
+                    TaskManager.runTask(whenDone);
+                }
             }
         };
-        manager.clearPlot(plotworld, plot, isDelete, run);
+        if (plotworld.TERRAIN != 0 || Settings.FAST_CLEAR) {
+            final Location pos2 = MainUtil.getPlotTopLoc(plot.world, plot.id);
+            ChunkManager.manager.regenerateRegion(pos1, pos2, run);
+            return;
+        }
+        manager.clearPlot(plotworld, plot, run);
     }
 
     public static void setCuboid(final String world, final Location pos1, final Location pos2, final PlotBlock[] blocks) {
@@ -1647,6 +1652,29 @@ public class MainUtil {
         }
         return true;
     }
+    
+    /**
+     * Send a message to the player
+     *
+     * @param plr Player to recieve message
+     * @param c   Caption to send
+     *
+     * @return boolean success
+     */
+    public static boolean sendMessage(final PlotPlayer plr, final C c, final Object... args) {
+        if (c.s().length() > 1) {
+            String msg = c.s();
+            if ((args != null) && (args.length > 0)) {
+                msg = C.format(c, args);
+            }
+            if (plr == null) {
+                PS.log(msg);
+            } else {
+                sendMessage(plr, msg, c.usePrefix());
+            }
+        }
+        return true;
+    }
 
     public static Plot getBottomPlot(final Plot plot) {
         if (plot.getSettings().getMerged(0)) {

src/main/java/com/intellectualcrafters/plot/util/Permissions.java

@@ -2,41 +2,19 @@ package com.intellectualcrafters.plot.util;
 
 import com.intellectualcrafters.plot.config.C;
 import com.intellectualcrafters.plot.object.PlotPlayer;
+import com.plotsquared.general.commands.CommandCaller;
 
-public enum Permissions {
-    // ADMIN
-    ADMIN("plots.admin", "do-not-change"),
-    STAR("*", "do-not-change"),
-    // BUILD
-    BUILD_OTHER("plots.admin.build.other", "build"),
-    BUILD_ROAD("plots.admin.build.road", "build"),
-    BUILD_UNOWNED("plots.admin.build.unowned", "build"),
-    // INTERACT
-    INTERACT_OTHER("plots.admin.interact.other", "interact"),
-    INTERACT_ROAD("plots.admin.interact.road", "interact"),
-    INTERACT_UNOWNED("plots.admin.interact.unowned", "interact"),
-    // BREAK
-    BREAK_OTHER("plots.admin.break.other", "break"),
-    BREAK_ROAD("plots.admin.break.road", "break"),
-    BREAK_UNOWNED("plots.admin.break.unowned", "break"),
-    // MERGE
-    MERGE_OTHER("plots.merge.other", "merge");
-    
-    public String s;
-    public String cat;
-    
-    Permissions(String perm, String cat) {
-        this.s = perm;
-        this.cat = cat;
+public class Permissions {
+    public static boolean hasPermission(final PlotPlayer player, final C c) {
+        return hasPermission(player, c.s());
     }
-    
-    public static boolean hasPermission(final PlotPlayer player, final Permissions perm) {
-        return hasPermission(player, perm.s);
-    }
-
 
     public static boolean hasPermission(final PlotPlayer player, final String perm) {
-        if ((player == null) || player.hasPermission(ADMIN.s) || player.hasPermission(STAR.s)) {
+        return hasPermission((CommandCaller) player, perm);
+    }
+
+    public static boolean hasPermission(final CommandCaller player, final String perm) {
+        if ((player == null) || player.hasPermission(C.PERMISSION_ADMIN.s()) || player.hasPermission(C.PERMISSION_STAR.s())) {
             return true;
         }
         if (player.hasPermission(perm)) {
@@ -46,7 +24,7 @@ public enum Permissions {
         final StringBuilder n = new StringBuilder();
         for (int i = 0; i < (nodes.length - 1); i++) {
             n.append(nodes[i] + ("."));
-            if (player.hasPermission(n + STAR.s)) {
+            if (player.hasPermission(n + C.PERMISSION_STAR.s())) {
                 return true;
             }
         }
@@ -64,7 +42,7 @@ public enum Permissions {
     }
 
     public static int hasPermissionRange(final PlotPlayer player, final String stub, final int range) {
-        if ((player == null) || player.hasPermission(ADMIN.s) || player.hasPermission(STAR.s)) {
+        if ((player == null) || player.hasPermission(C.PERMISSION_ADMIN.s()) || player.hasPermission(C.PERMISSION_STAR.s())) {
             return Integer.MAX_VALUE;
         }
         if (player.hasPermission(stub + ".*")) {