Fix plot swap and have a nicer static AIR block

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

@@ -4,6 +4,7 @@ import com.github.intellectualsites.plotsquared.bukkit.object.entity.EntityWrapp
 import com.github.intellectualsites.plotsquared.bukkit.object.entity.ReplicatingEntityWrapper;
 import com.github.intellectualsites.plotsquared.plot.PlotSquared;
 import com.github.intellectualsites.plotsquared.plot.generator.AugmentedUtils;
+import com.github.intellectualsites.plotsquared.plot.listener.WEExtent;
 import com.github.intellectualsites.plotsquared.plot.object.*;
 import com.github.intellectualsites.plotsquared.plot.util.ChunkManager;
 import com.github.intellectualsites.plotsquared.plot.util.TaskManager;
@@ -13,12 +14,15 @@ import com.github.intellectualsites.plotsquared.plot.util.block.ScopedLocalBlock
 import com.sk89q.worldedit.bukkit.BukkitWorld;
 import com.sk89q.worldedit.math.BlockVector3;
 import com.sk89q.worldedit.world.block.BaseBlock;
-import org.bukkit.*;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.World;
 import org.bukkit.block.Block;
-import org.bukkit.block.banner.Pattern;
 import org.bukkit.block.data.BlockData;
-import org.bukkit.entity.*;
+import org.bukkit.entity.Animals;
-import org.bukkit.inventory.ItemStack;
+import org.bukkit.entity.Creature;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
 
 import java.util.*;
 import java.util.Map.Entry;
@@ -61,10 +65,9 @@ public class BukkitChunkManager extends ChunkManager {
 
         for (int x = Math.max(r1.minX, sx); x <= Math.min(r1.maxX, sx + 15); x++) {
             for (int z = Math.max(r1.minZ, sz); z <= Math.min(r1.maxZ, sz + 15); z++) {
-                map.saveBlocks(bukkitWorld1, 256, sx, sz, relX, relZ);
                 for (int y = 0; y < 256; y++) {
                     Block block1 = world1.getBlockAt(x, y, z);
-                    BaseBlock baseBlock1 = bukkitWorld2.getFullBlock(BlockVector3.at(x, y, z));
+                    BaseBlock baseBlock1 = bukkitWorld1.getFullBlock(BlockVector3.at(x, y, z));
                     BlockData data1 = block1.getBlockData();
 
                     int xx = x + relX;
@@ -75,15 +78,15 @@ public class BukkitChunkManager extends ChunkManager {
                     BlockData data2 = block2.getBlockData();
 
                     if (block1.isEmpty()) {
-                        if (block2.isEmpty()) {
+                        if (!block2.isEmpty()) {
                             queue1.setBlock(x, y, z, baseBlock2);
-                            queue2.setBlock(xx, y, zz, PlotBlock.get("air"));
+                            queue2.setBlock(xx, y, zz, WEExtent.AIRBASE);
                         }
                     } else if (block2.isEmpty()) {
-                        queue1.setBlock(x, y, z, PlotBlock.get("air"));
+                        queue1.setBlock(x, y, z, WEExtent.AIRBASE);
                         queue2.setBlock(xx, y, zz, baseBlock1);
                     } else if (block1.equals(block2)) {
-                        if (data1 != data2) {
+                        if (!data1.matches(data2)) {
                             block1.setBlockData(data2);
                             block2.setBlockData(data1);
                         }
@@ -380,7 +383,6 @@ public class BukkitChunkManager extends ChunkManager {
         }
         GlobalBlockQueue.IMP.addTask(() -> {
             for (ContentMap map : maps) {
-                //map.restoreBlocks(world1, 0, 0);
                 map.restoreEntities(world1, 0, 0);
                 TaskManager.runTaskLater(whenDone, 1);
             }
@@ -589,44 +591,10 @@ public class BukkitChunkManager extends ChunkManager {
 
     public static class ContentMap {
 
-        final Map<BlockLoc, ItemStack[]> chestContents;
-        final Map<BlockLoc, ItemStack[]> furnaceContents;
-        final Map<BlockLoc, ItemStack[]> dispenserContents;
-        final Map<BlockLoc, ItemStack[]> dropperContents;
-        final Map<BlockLoc, ItemStack[]> brewingStandContents;
-        final Map<BlockLoc, ItemStack[]> beaconContents;
-        final Map<BlockLoc, ItemStack[]> hopperContents;
-        final Map<BlockLoc, Short[]> furnaceTime;
-        final Map<BlockLoc, Object[]> skullData;
-        final Map<BlockLoc, Material> jukeboxDisc;
-        final Map<BlockLoc, Short> brewTime;
-        final Map<BlockLoc, EntityType> spawnerData;
-        final Map<BlockLoc, String> cmdData;
-        final Map<BlockLoc, String[]> signContents;
-        final Map<BlockLoc, Note> noteBlockContents;
-        final Map<BlockLoc, List<Pattern>> bannerPatterns;
-        final Map<BlockLoc, DyeColor> bannerBase;
         final Set<EntityWrapper> entities;
         final Map<PlotLoc, BaseBlock[]> allBlocks;
 
         ContentMap() {
-            this.chestContents = new HashMap<>();
-            this.furnaceContents = new HashMap<>();
-            this.dispenserContents = new HashMap<>();
-            this.dropperContents = new HashMap<>();
-            this.brewingStandContents = new HashMap<>();
-            this.beaconContents = new HashMap<>();
-            this.hopperContents = new HashMap<>();
-            this.furnaceTime = new HashMap<>();
-            this.skullData = new HashMap<>();
-            this.brewTime = new HashMap<>();
-            this.jukeboxDisc = new HashMap<>();
-            this.spawnerData = new HashMap<>();
-            this.noteBlockContents = new HashMap<>();
-            this.signContents = new HashMap<>();
-            this.cmdData = new HashMap<>();
-            this.bannerBase = new HashMap<>();
-            this.bannerPatterns = new HashMap<>();
             this.entities = new HashSet<>();
             this.allBlocks = new HashMap<>();
         }
@@ -709,365 +677,6 @@ public class BukkitChunkManager extends ChunkManager {
             this.entities.clear();
         }
 
-/*        public void restoreBlocks(World world, int xOffset, int zOffset) {
-            for (Entry<BlockLoc, ItemStack[]> blockLocEntry : this.chestContents.entrySet()) {
-                try {
-                    Block block = world
-                        .getBlockAt(blockLocEntry.getKey().x + xOffset, blockLocEntry.getKey().y,
-                            blockLocEntry.getKey().z + zOffset);
-                    BlockState state = block.getState();
-                    if (state instanceof InventoryHolder) {
-                        InventoryHolder chest = (InventoryHolder) state;
-                        chest.getInventory().setContents(blockLocEntry.getValue());
-                        state.update(true);
-                    } else {
-                        PlotSquared.debug("&c[WARN] Plot clear failed to regenerate chest: " + (
-                            blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y
-                            + ',' + (blockLocEntry.getKey().z + zOffset));
-                    }
-                } catch (IllegalArgumentException ignored) {
-                    PlotSquared.debug("&c[WARN] Plot clear failed to regenerate chest (e): " + (
-                        blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y + ','
-                        + (blockLocEntry.getKey().z + zOffset));
-                }
-            }
-            for (Entry<BlockLoc, String[]> blockLocEntry : this.signContents.entrySet()) {
-                try {
-                    Block block = world
-                        .getBlockAt(blockLocEntry.getKey().x + xOffset, blockLocEntry.getKey().y,
-                            blockLocEntry.getKey().z + zOffset);
-                    BlockState state = block.getState();
-                    if (state instanceof Sign) {
-                        Sign sign = (Sign) state;
-                        int i = 0;
-                        for (String line : blockLocEntry.getValue()) {
-                            sign.setLine(i, line);
-                            i++;
-                        }
-                        state.update(true);
-                    } else {
-                        PlotSquared.debug("&c[WARN] Plot clear failed to regenerate sign: " + (
-                            blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y
-                            + ',' + (blockLocEntry.getKey().z + zOffset));
-                    }
-                } catch (IndexOutOfBoundsException ignored) {
-                    PlotSquared.debug("&c[WARN] Plot clear failed to regenerate sign: " + (
-                        blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y + ','
-                        + (blockLocEntry.getKey().z + zOffset));
-                }
-            }
-            for (Entry<BlockLoc, ItemStack[]> blockLocEntry : this.dispenserContents.entrySet()) {
-                try {
-                    Block block = world
-                        .getBlockAt(blockLocEntry.getKey().x + xOffset, blockLocEntry.getKey().y,
-                            blockLocEntry.getKey().z + zOffset);
-                    BlockState state = block.getState();
-                    if (state instanceof Dispenser) {
-                        ((InventoryHolder) state).getInventory()
-                            .setContents(blockLocEntry.getValue());
-                        state.update(true);
-                    } else {
-                        PlotSquared.debug("&c[WARN] Plot clear failed to regenerate dispenser: " + (
-                            blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y
-                            + ',' + (blockLocEntry.getKey().z + zOffset));
-                    }
-                } catch (IllegalArgumentException ignored) {
-                    PlotSquared.debug("&c[WARN] Plot clear failed to regenerate dispenser (e): " + (
-                        blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y + ','
-                        + (blockLocEntry.getKey().z + zOffset));
-                }
-            }
-            for (Entry<BlockLoc, ItemStack[]> blockLocEntry : this.dropperContents.entrySet()) {
-                try {
-                    Block block = world
-                        .getBlockAt(blockLocEntry.getKey().x + xOffset, blockLocEntry.getKey().y,
-                            blockLocEntry.getKey().z + zOffset);
-                    BlockState state = block.getState();
-                    if (state instanceof Dropper) {
-                        ((InventoryHolder) state).getInventory()
-                            .setContents(blockLocEntry.getValue());
-                        state.update(true);
-                    } else {
-                        PlotSquared.debug("&c[WARN] Plot clear failed to regenerate dispenser: " + (
-                            blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y
-                            + ',' + (blockLocEntry.getKey().z + zOffset));
-                    }
-                } catch (IllegalArgumentException ignored) {
-                    PlotSquared.debug("&c[WARN] Plot clear failed to regenerate dispenser (e): " + (
-                        blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y + ','
-                        + (blockLocEntry.getKey().z + zOffset));
-                }
-            }
-            for (Entry<BlockLoc, ItemStack[]> blockLocEntry : this.beaconContents.entrySet()) {
-                try {
-                    Block block = world
-                        .getBlockAt(blockLocEntry.getKey().x + xOffset, blockLocEntry.getKey().y,
-                            blockLocEntry.getKey().z + zOffset);
-                    BlockState state = block.getState();
-                    if (state instanceof Beacon) {
-                        ((InventoryHolder) state).getInventory()
-                            .setContents(blockLocEntry.getValue());
-                        state.update(true);
-                    } else {
-                        PlotSquared.debug("&c[WARN] Plot clear failed to regenerate beacon: " + (
-                            blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y
-                            + ',' + (blockLocEntry.getKey().z + zOffset));
-                    }
-                } catch (IllegalArgumentException ignored) {
-                    PlotSquared.debug("&c[WARN] Plot clear failed to regenerate beacon (e): " + (
-                        blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y + ','
-                        + (blockLocEntry.getKey().z + zOffset));
-                }
-            }
-            for (Entry<BlockLoc, Material> blockLocMaterialEntry : this.jukeboxDisc.entrySet()) {
-                try {
-                    Block block = world.getBlockAt(blockLocMaterialEntry.getKey().x + xOffset,
-                        blockLocMaterialEntry.getKey().y,
-                        blockLocMaterialEntry.getKey().z + zOffset);
-                    BlockState state = block.getState();
-                    if (state instanceof Jukebox) {
-                        ((Jukebox) state).setPlaying(blockLocMaterialEntry.getValue());
-                        state.update(true);
-                    } else {
-                        PlotSquared.debug("&c[WARN] Plot clear failed to restore jukebox: " + (
-                            blockLocMaterialEntry.getKey().x + xOffset) + ','
-                            + blockLocMaterialEntry.getKey().y + ',' + (
-                            blockLocMaterialEntry.getKey().z + zOffset));
-                    }
-                } catch (Exception ignored) {
-                    PlotSquared.debug("&c[WARN] Plot clear failed to regenerate jukebox (e): " + (
-                        blockLocMaterialEntry.getKey().x + xOffset) + ',' + blockLocMaterialEntry
-                        .getKey().y + ',' + (blockLocMaterialEntry.getKey().z + zOffset));
-                }
-            }
-            for (Entry<BlockLoc, Object[]> blockLocEntry : this.skullData.entrySet()) {
-                try {
-                    Block block = world
-                        .getBlockAt(blockLocEntry.getKey().x + xOffset, blockLocEntry.getKey().y,
-                            blockLocEntry.getKey().z + zOffset);
-                    BlockState state = block.getState();
-                    if (state instanceof Skull) {
-                        Object[] data = blockLocEntry.getValue();
-                        if ((Boolean) data[0]) {
-                            ((Skull) state).setOwner((String) data[1]);
-                        }
-                        ((Skull) state).setRotation((BlockFace) data[2]);
-                        ((Skull) state).setSkullType((SkullType) data[3]);
-                        state.update(true);
-                    } else {
-                        PlotSquared.debug("&c[WARN] Plot clear failed to restore skull: " + (
-                            blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y
-                            + ',' + (blockLocEntry.getKey().z + zOffset));
-                    }
-                } catch (Exception e) {
-                    PlotSquared.debug("&c[WARN] Plot clear failed to regenerate skull (e): " + (
-                        blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y + ','
-                        + (blockLocEntry.getKey().z + zOffset));
-                    e.printStackTrace();
-                }
-            }
-            for (Entry<BlockLoc, ItemStack[]> blockLocEntry : this.hopperContents.entrySet()) {
-                try {
-                    Block block = world
-                        .getBlockAt(blockLocEntry.getKey().x + xOffset, blockLocEntry.getKey().y,
-                            blockLocEntry.getKey().z + zOffset);
-                    BlockState state = block.getState();
-                    if (state instanceof Hopper) {
-                        ((InventoryHolder) state).getInventory()
-                            .setContents(blockLocEntry.getValue());
-                        state.update(true);
-                    } else {
-                        PlotSquared.debug("&c[WARN] Plot clear failed to regenerate hopper: " + (
-                            blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y
-                            + ',' + (blockLocEntry.getKey().z + zOffset));
-                    }
-                } catch (IllegalArgumentException ignored) {
-                    PlotSquared.debug("&c[WARN] Plot clear failed to regenerate hopper (e): " + (
-                        blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y + ','
-                        + (blockLocEntry.getKey().z + zOffset));
-                }
-            }
-            for (Entry<BlockLoc, Note> blockLocNoteEntry : this.noteBlockContents.entrySet()) {
-                try {
-                    Block block = world.getBlockAt(blockLocNoteEntry.getKey().x + xOffset,
-                        blockLocNoteEntry.getKey().y, blockLocNoteEntry.getKey().z + zOffset);
-                    BlockState state = block.getState();
-                    if (state instanceof NoteBlock) {
-                        ((NoteBlock) state).setNote(blockLocNoteEntry.getValue());
-                        state.update(true);
-                    } else {
-                        PlotSquared.debug(
-                            "&c[WARN] Plot clear failed to regenerate note block: " + (
-                                blockLocNoteEntry.getKey().x + xOffset) + ',' + blockLocNoteEntry
-                                .getKey().y + ',' + (blockLocNoteEntry.getKey().z + zOffset));
-                    }
-                } catch (Exception ignored) {
-                    PlotSquared.debug(
-                        "&c[WARN] Plot clear failed to regenerate note block (e): " + (
-                            blockLocNoteEntry.getKey().x + xOffset) + ',' + blockLocNoteEntry
-                            .getKey().y + ',' + (blockLocNoteEntry.getKey().z + zOffset));
-                }
-            }
-            for (Entry<BlockLoc, Short> blockLocShortEntry : this.brewTime.entrySet()) {
-                try {
-                    Block block = world.getBlockAt(blockLocShortEntry.getKey().x + xOffset,
-                        blockLocShortEntry.getKey().y, blockLocShortEntry.getKey().z + zOffset);
-                    BlockState state = block.getState();
-                    if (state instanceof BrewingStand) {
-                        ((BrewingStand) state).setBrewingTime(blockLocShortEntry.getValue());
-                    } else {
-                        PlotSquared.debug(
-                            "&c[WARN] Plot clear failed to restore brewing stand cooking: " + (
-                                blockLocShortEntry.getKey().x + xOffset) + ',' + blockLocShortEntry
-                                .getKey().y + ',' + (blockLocShortEntry.getKey().z + zOffset));
-                    }
-                } catch (Exception ignored) {
-                    PlotSquared.debug(
-                        "&c[WARN] Plot clear failed to restore brewing stand cooking (e): " + (
-                            blockLocShortEntry.getKey().x + xOffset) + ',' + blockLocShortEntry
-                            .getKey().y + ',' + (blockLocShortEntry.getKey().z + zOffset));
-                }
-            }
-            for (Entry<BlockLoc, EntityType> blockLocEntityTypeEntry : this.spawnerData
-                .entrySet()) {
-                try {
-                    Block block = world.getBlockAt(blockLocEntityTypeEntry.getKey().x + xOffset,
-                        blockLocEntityTypeEntry.getKey().y,
-                        blockLocEntityTypeEntry.getKey().z + zOffset);
-                    BlockState state = block.getState();
-                    if (state instanceof CreatureSpawner) {
-                        ((CreatureSpawner) state)
-                            .setSpawnedType(blockLocEntityTypeEntry.getValue());
-                        state.update(true);
-                    } else {
-                        PlotSquared.debug("&c[WARN] Plot clear failed to restore spawner type: " + (
-                            blockLocEntityTypeEntry.getKey().x + xOffset) + ','
-                            + blockLocEntityTypeEntry.getKey().y + ',' + (
-                            blockLocEntityTypeEntry.getKey().z + zOffset));
-                    }
-                } catch (Exception ignored) {
-                    PlotSquared.debug("&c[WARN] Plot clear failed to restore spawner type (e): " + (
-                        blockLocEntityTypeEntry.getKey().x + xOffset) + ','
-                        + blockLocEntityTypeEntry.getKey().y + ',' + (
-                        blockLocEntityTypeEntry.getKey().z + zOffset));
-                }
-            }
-            for (Entry<BlockLoc, String> blockLocStringEntry : this.cmdData.entrySet()) {
-                try {
-                    Block block = world.getBlockAt(blockLocStringEntry.getKey().x + xOffset,
-                        blockLocStringEntry.getKey().y, blockLocStringEntry.getKey().z + zOffset);
-                    BlockState state = block.getState();
-                    if (state instanceof CommandBlock) {
-                        ((CommandBlock) state).setCommand(blockLocStringEntry.getValue());
-                        state.update(true);
-                    } else {
-                        PlotSquared.debug(
-                            "&c[WARN] Plot clear failed to restore command block: " + (
-                                blockLocStringEntry.getKey().x + xOffset) + ','
-                                + blockLocStringEntry.getKey().y + ',' + (
-                                blockLocStringEntry.getKey().z + zOffset));
-                    }
-                } catch (Exception ignored) {
-                    PlotSquared.debug(
-                        "&c[WARN] Plot clear failed to restore command block (e): " + (
-                            blockLocStringEntry.getKey().x + xOffset) + ',' + blockLocStringEntry
-                            .getKey().y + ',' + (blockLocStringEntry.getKey().z + zOffset));
-                }
-            }
-            for (Entry<BlockLoc, ItemStack[]> blockLocEntry : this.brewingStandContents
-                .entrySet()) {
-                try {
-                    Block block = world
-                        .getBlockAt(blockLocEntry.getKey().x + xOffset, blockLocEntry.getKey().y,
-                            blockLocEntry.getKey().z + zOffset);
-                    BlockState state = block.getState();
-                    if (state instanceof BrewingStand) {
-                        ((InventoryHolder) state).getInventory()
-                            .setContents(blockLocEntry.getValue());
-                        state.update(true);
-                    } else {
-                        PlotSquared.debug(
-                            "&c[WARN] Plot clear failed to regenerate brewing stand: " + (
-                                blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y
-                                + ',' + (blockLocEntry.getKey().z + zOffset));
-                    }
-                } catch (IllegalArgumentException ignored) {
-                    PlotSquared.debug(
-                        "&c[WARN] Plot clear failed to regenerate brewing stand (e): " + (
-                            blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y
-                            + ',' + (blockLocEntry.getKey().z + zOffset));
-                }
-            }
-            for (Entry<BlockLoc, Short[]> blockLocEntry : this.furnaceTime.entrySet()) {
-                try {
-                    Block block = world
-                        .getBlockAt(blockLocEntry.getKey().x + xOffset, blockLocEntry.getKey().y,
-                            blockLocEntry.getKey().z + zOffset);
-                    BlockState state = block.getState();
-                    if (state instanceof Furnace) {
-                        Short[] time = blockLocEntry.getValue();
-                        ((Furnace) state).setBurnTime(time[0]);
-                        ((Furnace) state).setCookTime(time[1]);
-                    } else {
-                        PlotSquared.debug(
-                            "&c[WARN] Plot clear failed to restore furnace cooking: " + (
-                                blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y
-                                + ',' + (blockLocEntry.getKey().z + zOffset));
-                    }
-                } catch (Exception ignored) {
-                    PlotSquared.debug(
-                        "&c[WARN] Plot clear failed to restore furnace cooking (e): " + (
-                            blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y
-                            + ',' + (blockLocEntry.getKey().z + zOffset));
-                }
-            }
-            for (Entry<BlockLoc, ItemStack[]> blockLocEntry : this.furnaceContents.entrySet()) {
-                try {
-                    Block block = world
-                        .getBlockAt(blockLocEntry.getKey().x + xOffset, blockLocEntry.getKey().y,
-                            blockLocEntry.getKey().z + zOffset);
-                    BlockState state = block.getState();
-                    if (state instanceof Furnace) {
-                        ((InventoryHolder) state).getInventory()
-                            .setContents(blockLocEntry.getValue());
-                        state.update(true);
-                    } else {
-                        PlotSquared.debug("&c[WARN] Plot clear failed to regenerate furnace: " + (
-                            blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y
-                            + ',' + (blockLocEntry.getKey().z + zOffset));
-                    }
-                } catch (IllegalArgumentException ignored) {
-                    PlotSquared.debug("&c[WARN] Plot clear failed to regenerate furnace (e): " + (
-                        blockLocEntry.getKey().x + xOffset) + ',' + blockLocEntry.getKey().y + ','
-                        + (blockLocEntry.getKey().z + zOffset));
-                }
-            }
-            for (Entry<BlockLoc, DyeColor> blockLocByteEntry : this.bannerBase.entrySet()) {
-                try {
-                    Block block = world.getBlockAt(blockLocByteEntry.getKey().x + xOffset,
-                        blockLocByteEntry.getKey().y, blockLocByteEntry.getKey().z + zOffset);
-                    BlockState state = block.getState();
-                    if (state instanceof Banner) {
-                        Banner banner = (Banner) state;
-                        DyeColor base = blockLocByteEntry.getValue();
-                        List<Pattern> patterns =
-                            this.bannerPatterns.get(blockLocByteEntry.getKey());
-                        banner.setBaseColor(base);
-                        banner.setPatterns(patterns);
-                        state.update(true);
-                    } else {
-                        PlotSquared.debug("&c[WARN] Plot clear failed to regenerate banner: " + (
-                            blockLocByteEntry.getKey().x + xOffset) + ',' + blockLocByteEntry
-                            .getKey().y + ',' + (blockLocByteEntry.getKey().z + zOffset));
-                    }
-                } catch (Exception ignored) {
-                    PlotSquared.debug("&c[WARN] Plot clear failed to regenerate banner (e): " + (
-                        blockLocByteEntry.getKey().x + xOffset) + ',' + blockLocByteEntry.getKey().y
-                        + ',' + (blockLocByteEntry.getKey().z + zOffset));
-                }
-            }
-        }*/
-
         public void saveBlocks(BukkitWorld world, int maxY, int x, int z, int offsetX,
             int offsetZ) {
             maxY = Math.min(255, maxY);
@@ -1076,99 +685,6 @@ public class BukkitChunkManager extends ChunkManager {
             for (short y = 0; y <= maxY; y++) {
                 BaseBlock block = world.getFullBlock(BlockVector3.at(x, y, z));
                 ids[y] = block;
-/*                if (storeNormal) {
-                    if (block.isEmpty()) {
-                        BukkitAdapter.
-                            ids[y] =
-                            BukkitAdapter.adapt(Material.AIR.createBlockData()).toBaseBlock();
-                    } else {
-                        ids[y] = BukkitAdapter.adapt(block.getBlockData()).toBaseBlock();
-                    }
-                }
-                if (!blockType.name().contains("AIR")) {
-                    try {
-                        BlockLoc bl = new BlockLoc(x + offsetX, y, z + offsetZ);
-                        if (block.getState() instanceof InventoryHolder) {
-                            InventoryHolder inventoryHolder = (InventoryHolder) block.getState();
-                            ItemStack[] inventory =
-                                inventoryHolder.getInventory().getContents().clone();
-                            switch (blockType) {
-                                case CHEST:
-                                    this.chestContents.put(bl, inventory);
-                                    break;
-                                case DISPENSER:
-                                    this.dispenserContents.put(bl, inventory);
-                                    break;
-                                case BEACON:
-                                    this.beaconContents.put(bl, inventory);
-                                    break;
-                                case DROPPER:
-                                    this.dropperContents.put(bl, inventory);
-                                    break;
-                                case HOPPER:
-                                    this.hopperContents.put(bl, inventory);
-                                    break;
-                                case BREWING_STAND:
-                                    BrewingStand brewingStand = (BrewingStand) inventoryHolder;
-                                    short time = (short) brewingStand.getBrewingTime();
-                                    if (time > 0) {
-                                        this.brewTime.put(bl, time);
-                                    }
-                                    ItemStack[] invBre =
-                                        brewingStand.getInventory().getContents().clone();
-                                    this.brewingStandContents.put(bl, invBre);
-                                    break;
-                                case FURNACE:
-                                    Furnace furnace = (Furnace) inventoryHolder;
-                                    short burn = furnace.getBurnTime();
-                                    short cook = furnace.getCookTime();
-                                    ItemStack[] invFur =
-                                        furnace.getInventory().getContents().clone();
-                                    this.furnaceContents.put(bl, invFur);
-                                    if (cook != 0) {
-                                        this.furnaceTime.put(bl, new Short[] {burn, cook});
-                                    }
-                                    break;
-                            }
-                        } else if (block.getState() instanceof CreatureSpawner) {
-                            CreatureSpawner spawner = (CreatureSpawner) block.getState();
-                            EntityType type = spawner.getSpawnedType();
-                            if (type != null) {
-                                this.spawnerData.put(bl, type);
-                            }
-                        } else if (block.getState() instanceof CommandBlock) {
-                            CommandBlock cmd = (CommandBlock) block.getState();
-                            String string = cmd.getCommand();
-                            if (string != null && !string.isEmpty()) {
-                                this.cmdData.put(bl, string);
-                            }
-                        } else if (block.getState() instanceof NoteBlock) {
-                            NoteBlock noteBlock = (NoteBlock) block.getState();
-                            Note note = noteBlock.getNote();
-                            this.noteBlockContents.put(bl, note);
-                        } else if (block.getState() instanceof Jukebox) {
-                            Jukebox jukebox = (Jukebox) block.getState();
-                            Material playing = jukebox.getPlaying();
-                            if (playing != null) {
-                                this.jukeboxDisc.put(bl, playing);
-                            }
-                        } else if (block.getState() instanceof Skull) {
-                            Skull skull = (Skull) block.getState();
-                            this.skullData.put(bl, new Object[] {skull.hasOwner(), skull.getOwner(),
-                                skull.getRotation(), skull.getSkullType()});
-                        } else if (block.getState() instanceof Banner) {
-                            Banner banner = (Banner) block.getState();
-                            DyeColor base = banner.getBaseColor();
-                            this.bannerBase.put(bl, base);
-                            this.bannerPatterns.put(bl, banner.getPatterns());
-
-                        }
-                    } catch (Exception e) {
-                        PlotSquared.debug("------------ FAILED TO DO SOMETHING --------");
-                        e.printStackTrace();
-                        PlotSquared.debug("------------ but we caught it ^ --------");
-                    }
-                }*/
             }
             PlotLoc loc = new PlotLoc(x + offsetX, z + offsetZ);
             this.allBlocks.put(loc, ids);

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

@@ -18,6 +18,7 @@ import org.bukkit.Material;
 import org.bukkit.World;
 import org.bukkit.block.Biome;
 import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
@@ -124,14 +125,16 @@ public class BukkitLocalQueue<T> extends BasicLocalBlockQueue<T> {
                         int y = MainUtil.y_loc[layer][j];
                         int z = MainUtil.z_loc[layer][j];
 
+                        BlockData blockData = BukkitAdapter.adapt(block);
+
                         Block existing = chunk.getBlock(x, y, z);
                         if (equals(PlotBlock.get(block), existing) && existing.getBlockData()
-                            .matches(BukkitAdapter.adapt(block))) {
+                            .matches(blockData)) {
                             continue;
                         }
 
                         existing.setType(BukkitAdapter.adapt(block.getBlockType()), false);
-                        existing.setBlockData(BukkitAdapter.adapt(block), false);
+                        existing.setBlockData(blockData, false);
                         if (block.hasNbtData()) {
                             CompoundTag tag = block.getNbtData();
                             StateWrapper sw = new StateWrapper(tag);

Core/src/main/java/com/github/intellectualsites/plotsquared/plot/config/C.java

@@ -184,6 +184,8 @@ public enum C {
      * Area Create
      */
 
+    REQUIRES_UNMERGED("$2The plot cannot be merged", "debug"),
+
     SET_ATTRIBUTE("$4Successfully set %s0 set to %s1", "Set"), /*
      * Web
      */
@@ -617,7 +619,7 @@ public enum C {
      */
 
     DEBUG_HEADER("$1Debug Information&-", "Debug"), DEBUG_SECTION("$2>> $1&l%val%", "Debug"),
-    REQUIRES_UNMERGED("$2The plot cannot be merged", "Debug"),
+
     DEBUG_LINE("$2>> $1%var%$2:$1 %val%&-", "Debug"), /*
      * Invalid
      */

Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/HybridUtils.java

@@ -4,6 +4,8 @@ import com.github.intellectualsites.plotsquared.plot.PlotSquared;
 import com.github.intellectualsites.plotsquared.plot.config.C;
 import com.github.intellectualsites.plotsquared.plot.flag.FlagManager;
 import com.github.intellectualsites.plotsquared.plot.flag.Flags;
+import com.github.intellectualsites.plotsquared.plot.listener.WEExtent;
+import com.github.intellectualsites.plotsquared.plot.listener.WEManager;
 import com.github.intellectualsites.plotsquared.plot.object.*;
 import com.github.intellectualsites.plotsquared.plot.util.*;
 import com.github.intellectualsites.plotsquared.plot.util.block.GlobalBlockQueue;
@@ -24,7 +26,6 @@ public abstract class HybridUtils {
     public static Set<ChunkLoc> chunks = new HashSet<>();
     public static PlotArea area;
     public static boolean UPDATE = false;
-    private static BaseBlock air = BlockTypes.AIR.getDefaultState().toBaseBlock();
 
     public abstract void analyzeRegion(String world, RegionWrapper region,
         RunnableVal<PlotAnalysis> whenDone);
@@ -361,7 +362,7 @@ public abstract class HybridUtils {
                                         } else if (y <= extend) {
                                             queue
                                                 .setBlock(x + X + plotWorld.ROAD_OFFSET_X, minY + y,
-                                                    z + Z + plotWorld.ROAD_OFFSET_Z, air);
+                                                    z + Z + plotWorld.ROAD_OFFSET_Z, WEExtent.AIRBASE);
                                         }
                                     }
                                 }

Core/src/main/java/com/github/intellectualsites/plotsquared/plot/listener/ProcessedWEExtent.java

@@ -50,14 +50,14 @@ public class ProcessedWEExtent extends AbstractDelegateExtent {
         if (WEManager.maskContains(this.mask, location.getX(), location.getY(), location.getZ())) {
             return super.getBlock(location);
         }
-        return WEManager.AIR;
+        return WEExtent.AIRSTATE;
     }
 
     @Override public BaseBlock getFullBlock(BlockVector3 location) {
         if (WEManager.maskContains(this.mask, location.getX(), location.getY(), location.getZ())) {
             return super.getFullBlock(location);
         }
-        return WEManager.AIR.toBaseBlock();
+        return WEExtent.AIRBASE;
     }
 
     @Override public boolean setBlock(BlockVector3 location, BlockStateHolder block)

Core/src/main/java/com/github/intellectualsites/plotsquared/plot/listener/WEExtent.java

@@ -10,9 +10,7 @@ import com.sk89q.worldedit.math.BlockVector2;
 import com.sk89q.worldedit.math.BlockVector3;
 import com.sk89q.worldedit.util.Location;
 import com.sk89q.worldedit.world.biome.BaseBiome;
-import com.sk89q.worldedit.world.block.BaseBlock;
+import com.sk89q.worldedit.world.block.*;
-import com.sk89q.worldedit.world.block.BlockState;
-import com.sk89q.worldedit.world.block.BlockStateHolder;
 
 import java.util.HashSet;
 
@@ -20,6 +18,9 @@ public class WEExtent extends AbstractDelegateExtent {
 
     private final HashSet<RegionWrapper> mask;
 
+    public static BlockState AIRSTATE = BlockTypes.AIR.getDefaultState();
+    public static BaseBlock AIRBASE = BlockTypes.AIR.getDefaultState().toBaseBlock();
+
     public WEExtent(HashSet<RegionWrapper> mask, Extent extent) {
         super(extent);
         this.mask = mask;
@@ -48,13 +49,13 @@ public class WEExtent extends AbstractDelegateExtent {
         if (WEManager.maskContains(this.mask, location.getX(), location.getY(), location.getZ())) {
             return super.getBlock(location);
         }
-        return WEManager.AIR;
+        return AIRSTATE;
     }
 
     @Override public BaseBlock getFullBlock(BlockVector3 location) {
         if (WEManager.maskContains(this.mask, location.getX(), location.getY(), location.getZ())) {
             return super.getFullBlock(location);
         }
-        return WEManager.AIR.toBaseBlock();
+        return AIRBASE;
     }
 }

Core/src/main/java/com/github/intellectualsites/plotsquared/plot/listener/WEManager.java

@@ -4,6 +4,7 @@ import com.github.intellectualsites.plotsquared.plot.PlotSquared;
 import com.github.intellectualsites.plotsquared.plot.config.Settings;
 import com.github.intellectualsites.plotsquared.plot.flag.Flags;
 import com.github.intellectualsites.plotsquared.plot.object.*;
+import com.sk89q.worldedit.world.block.BaseBlock;
 import com.sk89q.worldedit.world.block.BlockState;
 import com.sk89q.worldedit.world.block.BlockType;
 
@@ -12,9 +13,6 @@ import java.util.UUID;
 
 public class WEManager {
 
-
-    public static BlockState AIR = new BlockType("AIR").getDefaultState();
-
     public static boolean maskContains(HashSet<RegionWrapper> mask, int x, int y, int z) {
         for (RegionWrapper region : mask) {
             if (region.isIn(x, y, z)) {