Merge pull request #2847 from IntellectualSites/features/v5/single-area

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

@@ -348,7 +348,7 @@ public class BukkitRegionManager extends RegionManager {
                         CuboidRegion currentPlotClear = RegionUtil
                             .createRegion(pos1.getX(), pos2.getX(), pos1.getZ(), pos2.getZ());
                         map.saveEntitiesOut(chunkObj, currentPlotClear);
-                        AugmentedUtils.bypass(ignoreAugment, () -> ChunkManager.manager
+                        AugmentedUtils.bypass(ignoreAugment, () -> ChunkManager
                             .setChunkInPlotArea(null, new RunnableVal<ScopedLocalBlockQueue>() {
                                 @Override public void run(ScopedLocalBlockQueue value) {
                                     Location min = value.getMin();

Core/src/main/java/com/plotsquared/core/PlotSquared.java

@@ -53,6 +53,7 @@ import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.BlockBucket;
 import com.plotsquared.core.plot.Plot;
 import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.plot.PlotAreaTerrainType;
 import com.plotsquared.core.plot.PlotAreaType;
 import com.plotsquared.core.plot.PlotCluster;
 import com.plotsquared.core.plot.PlotFilter;
@@ -91,6 +92,7 @@ import com.sk89q.worldedit.regions.CuboidRegion;
 import lombok.Getter;
 import lombok.NonNull;
 import lombok.Setter;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.io.BufferedReader;
@@ -272,7 +274,8 @@ public class PlotSquared {
             // create setup util class
             SetupUtils.manager = this.IMP.initSetupUtils();
             // Set block
-            GlobalBlockQueue.IMP = new GlobalBlockQueue(IMP.initBlockQueue(), 1, Settings.QUEUE.TARGET_TIME);
+            GlobalBlockQueue.IMP =
+                new GlobalBlockQueue(IMP.initBlockQueue(), 1, Settings.QUEUE.TARGET_TIME);
             GlobalBlockQueue.IMP.runTask();
             // Set chunk
             ChunkManager.manager = this.IMP.initChunkManager();
@@ -1975,6 +1978,23 @@ public class PlotSquared {
         return Collections.unmodifiableSet(set);
     }
 
+    /**
+     * Check if the chunk uses vanilla/non-PlotSquared generation
+     *
+     * @param world            World name
+     * @param chunkCoordinates Chunk coordinates
+     * @return True if the chunk uses non-standard generation, false if not
+     */
+    public boolean isNonStandardGeneration(@NotNull final String world,
+        @NotNull final BlockVector2 chunkCoordinates) {
+        final Location location = new Location(world, chunkCoordinates.getBlockX() << 4, 64, chunkCoordinates.getBlockZ() << 4);
+        final PlotArea area = plotAreaManager.getApplicablePlotArea(location);
+        if (area == null) {
+            return true;
+        }
+        return area.getTerrain() != PlotAreaTerrainType.NONE;
+    }
+
     public boolean isAugmented(@NonNull final String world) {
         final PlotArea[] areas = plotAreaManager.getPlotAreas(world, null);
         return areas != null && (areas.length > 1 || areas[0].getType() != PlotAreaType.NORMAL);

Core/src/main/java/com/plotsquared/core/command/Area.java

@@ -33,6 +33,7 @@ import com.plotsquared.core.events.TeleportCause;
 import com.plotsquared.core.generator.AugmentedUtils;
 import com.plotsquared.core.generator.HybridPlotWorld;
 import com.plotsquared.core.location.Location;
+import com.plotsquared.core.player.ConsolePlayer;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.PlotArea;
 import com.plotsquared.core.plot.PlotAreaTerrainType;
@@ -45,14 +46,28 @@ import com.plotsquared.core.util.MathMan;
 import com.plotsquared.core.util.Permissions;
 import com.plotsquared.core.util.RegionManager;
 import com.plotsquared.core.util.RegionUtil;
+import com.plotsquared.core.util.SchematicHandler;
 import com.plotsquared.core.util.SetupUtils;
 import com.plotsquared.core.util.StringMan;
 import com.plotsquared.core.util.WorldUtil;
 import com.plotsquared.core.util.task.RunnableVal;
 import com.plotsquared.core.util.task.RunnableVal3;
+import com.sk89q.worldedit.EditSession;
+import com.sk89q.worldedit.LocalSession;
+import com.sk89q.worldedit.WorldEdit;
+import com.sk89q.worldedit.entity.Player;
+import com.sk89q.worldedit.extent.clipboard.BlockArrayClipboard;
+import com.sk89q.worldedit.extent.clipboard.io.BuiltInClipboardFormat;
+import com.sk89q.worldedit.extent.clipboard.io.ClipboardWriter;
+import com.sk89q.worldedit.function.operation.ForwardExtentCopy;
+import com.sk89q.worldedit.function.operation.Operations;
 import com.sk89q.worldedit.math.BlockVector2;
+import com.sk89q.worldedit.math.BlockVector3;
 import com.sk89q.worldedit.regions.CuboidRegion;
+import com.sk89q.worldedit.regions.Region;
 
+import java.io.File;
+import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Objects;
@@ -74,6 +89,139 @@ public class Area extends SubCommand {
             return false;
         }
         switch (args[0].toLowerCase()) {
+            case "single":
+                if (player instanceof ConsolePlayer) {
+                    MainUtil.sendMessage(player, Captions.IS_CONSOLE);
+                    return false;
+                }
+                if (!Permissions.hasPermission(player, Captions.PERMISSION_AREA_CREATE)) {
+                    MainUtil.sendMessage(player, Captions.NO_PERMISSION, Captions.PERMISSION_AREA_CREATE);
+                    return false;
+                }
+                if (args.length < 2) {
+                    MainUtil.sendMessage(player, Captions.SINGLE_AREA_NEEDS_NAME);
+                    return false;
+                }
+                final PlotArea existingArea = PlotSquared.get().getPlotArea(player.getLocation().getWorld(), args[1]);
+                if (existingArea != null && existingArea.getId().equalsIgnoreCase(args[1])) {
+                    MainUtil.sendMessage(player, Captions.SINGLE_AREA_NAME_TAKEN);
+                    return false;
+                }
+                final LocalSession localSession = WorldEdit.getInstance().getSessionManager().getIfPresent(player.toActor());
+                if (localSession == null) {
+                    MainUtil.sendMessage(player, Captions.SINGLE_AREA_MISSING_SELECTION);
+                    return false;
+                }
+                Region playerSelectedRegion = null;
+                try {
+                    playerSelectedRegion = localSession.getSelection(((Player) player.toActor()).getWorld());
+                } catch (final Exception ignored) {}
+                if (playerSelectedRegion == null) {
+                    MainUtil.sendMessage(player, Captions.SINGLE_AREA_MISSING_SELECTION);
+                    return false;
+                }
+                if (playerSelectedRegion.getWidth() != playerSelectedRegion.getLength()) {
+                    MainUtil.sendMessage(player, Captions.SINGLE_AREA_NOT_SQUARE);
+                    return false;
+                }
+                if (PlotSquared.get().getPlotAreaManager().getPlotAreas(
+                    Objects.requireNonNull(playerSelectedRegion.getWorld()).getName(), CuboidRegion.makeCuboid(playerSelectedRegion)).length != 0) {
+                    MainUtil.sendMessage(player, Captions.SINGLE_AREA_OVERLAPPING);
+                }
+                // Alter the region
+                final BlockVector3 playerSelectionMin = playerSelectedRegion.getMinimumPoint();
+                final BlockVector3 playerSelectionMax = playerSelectedRegion.getMaximumPoint();
+                // Create a new selection that spans the entire vertical range of the world
+                final CuboidRegion selectedRegion = new CuboidRegion(playerSelectedRegion.getWorld(),
+                    BlockVector3.at(playerSelectionMin.getX(), 0, playerSelectionMin.getZ()),
+                    BlockVector3.at(playerSelectionMax.getX(), 255, playerSelectionMax.getZ()));
+                // There's only one plot in the area...
+                final PlotId plotId = new PlotId(1, 1);
+                final HybridPlotWorld hybridPlotWorld = new HybridPlotWorld(player.getLocation().getWorld(), args[1],
+                    Objects.requireNonNull(PlotSquared.imp()).getDefaultGenerator(), plotId, plotId);
+                // Plot size is the same as the region width
+                hybridPlotWorld.PLOT_WIDTH = hybridPlotWorld.SIZE = (short) selectedRegion.getWidth();
+                // We use a schematic generator
+                hybridPlotWorld.setTerrain(PlotAreaTerrainType.NONE);
+                // It is always a partial plot world
+                hybridPlotWorld.setType(PlotAreaType.PARTIAL);
+                // We save the schematic :D
+                hybridPlotWorld.PLOT_SCHEMATIC = true;
+                // Set the road width to 0
+                hybridPlotWorld.ROAD_WIDTH = hybridPlotWorld.ROAD_OFFSET_X = hybridPlotWorld.ROAD_OFFSET_Z = 0;
+                // Set the plot height to the selection height
+                hybridPlotWorld.PLOT_HEIGHT = hybridPlotWorld.ROAD_HEIGHT = hybridPlotWorld.WALL_HEIGHT = playerSelectionMin.getBlockY();
+                // No sign plz
+                hybridPlotWorld.setAllowSigns(false);
+                final File parentFile = MainUtil.getFile(PlotSquared.imp().getDirectory(), "schematics" + File.separator +
+                    "GEN_ROAD_SCHEMATIC" + File.separator + hybridPlotWorld.getWorldName() + File.separator +
+                    hybridPlotWorld.getId());
+                if (!parentFile.exists() && !parentFile.mkdirs()) {
+                    MainUtil.sendMessage(player, Captions.SINGLE_AREA_COULD_NOT_MAKE_DIRECTORIES);
+                    return false;
+                }
+                final File file = new File(parentFile, "plot.schem");
+                try (final ClipboardWriter clipboardWriter = BuiltInClipboardFormat.SPONGE_SCHEMATIC.getWriter(new FileOutputStream(file))) {
+                    final BlockArrayClipboard clipboard = new BlockArrayClipboard(selectedRegion);
+                    final EditSession editSession = WorldEdit.getInstance().getEditSessionFactory().getEditSession(selectedRegion.getWorld(), -1);
+                    final ForwardExtentCopy forwardExtentCopy = new ForwardExtentCopy(editSession, selectedRegion, clipboard, selectedRegion.getMinimumPoint());
+                    forwardExtentCopy.setCopyingBiomes(true);
+                    forwardExtentCopy.setCopyingEntities(true);
+                    Operations.complete(forwardExtentCopy);
+                    clipboardWriter.write(clipboard);
+                } catch (final Exception e) {
+                    MainUtil.sendMessage(player, Captions.SINGLE_AREA_FAILED_TO_SAVE);
+                    e.printStackTrace();
+                    return false;
+                }
+
+                // Setup schematic
+                try {
+                    hybridPlotWorld.setupSchematics();
+                } catch (final SchematicHandler.UnsupportedFormatException e) {
+                    e.printStackTrace();
+                }
+
+                // Calculate the offset
+                final BlockVector3 singlePos1 = selectedRegion.getMinimumPoint();
+
+                // Now the schematic is saved, which is wonderful!
+                final SetupObject singleSetup = new SetupObject();
+                singleSetup.world = hybridPlotWorld.getWorldName();
+                singleSetup.id = hybridPlotWorld.getId();
+                singleSetup.terrain = hybridPlotWorld.getTerrain();
+                singleSetup.type = hybridPlotWorld.getType();
+                singleSetup.plotManager = PlotSquared.imp().getPluginName();
+                singleSetup.setupGenerator = PlotSquared.imp().getPluginName();
+                singleSetup.step = hybridPlotWorld.getSettingNodes();
+                singleSetup.max = plotId;
+                singleSetup.min = plotId;
+                Runnable singleRun = () -> {
+                    final String path =
+                        "worlds." + hybridPlotWorld.getWorldName() + ".areas." + hybridPlotWorld.getId() + '-'
+                            + singleSetup.min + '-' + singleSetup.max;
+                    final int offsetX = singlePos1.getX();
+                    final int offsetZ = singlePos1.getZ();
+                    if (offsetX != 0) {
+                        PlotSquared.get().worlds
+                            .set(path + ".road.offset.x", offsetX);
+                    }
+                    if (offsetZ != 0) {
+                        PlotSquared.get().worlds
+                            .set(path + ".road.offset.z", offsetZ);
+                    }
+                    final String world = SetupUtils.manager.setupWorld(singleSetup);
+                    if (WorldUtil.IMP.isWorld(world)) {
+                        PlotSquared.get().loadWorld(world, null);
+                        MainUtil.sendMessage(player, Captions.SINGLE_AREA_CREATED);
+                    } else {
+                        MainUtil.sendMessage(player,
+                            "An error occurred while creating the world: " + hybridPlotWorld
+                                .getWorldName());
+                    }
+                };
+                singleRun.run();
+                return true;
             case "c":
             case "setup":
             case "create":

Core/src/main/java/com/plotsquared/core/configuration/Captions.java

@@ -783,6 +783,17 @@ public enum Captions implements Caption {
     GENERIC_INVALID_CHOICE("invalid choice", "Generic"),
     //</editor-fold>
 
+    //<editor-fold des="Single area">
+    SINGLE_AREA_MISSING_SELECTION("$2Error! You need to select a square region", "Single"),
+    SINGLE_AREA_NOT_SQUARE("$2Error! Your selection needs to be a square", "Single"),
+    SINGLE_AREA_OVERLAPPING("$2Error! Your selection overlaps with an existing plot area", "Single"),
+    SINGLE_AREA_NEEDS_NAME("$2Error! Please specify a plot name: /plot area single <name>", "Single"),
+    SINGLE_AREA_NAME_TAKEN("$2Error! The plot name is already taken", "Single"),
+    SINGLE_AREA_FAILED_TO_SAVE("$2Error! Failed to save the area schematic", "Single"),
+    SINGLE_AREA_COULD_NOT_MAKE_DIRECTORIES("$2Error! Failed to create the schematic directory", "Single"),
+    SINGLE_AREA_CREATED("$1The area was created successfully!", "Single"),
+    //</editor-fold>
+
     /**
      * Legacy Configuration Conversion
      */

Core/src/main/java/com/plotsquared/core/generator/HybridPlotWorld.java

@@ -195,8 +195,16 @@ public class HybridPlotWorld extends ClassicPlotWorld {
     public void setupSchematics() throws SchematicHandler.UnsupportedFormatException {
         this.G_SCH = new HashMap<>();
         this.G_SCH_B = new HashMap<>();
-        File root = MainUtil.getFile(PlotSquared.get().IMP.getDirectory(),
+
-            "schematics/GEN_ROAD_SCHEMATIC/" + this.getWorldName());
+        // Try to determine root. This means that plot areas can have separate schematic
+        // directories
+        File root;
+        if (!(root = MainUtil.getFile(PlotSquared.get().IMP.getDirectory(), "schematics/GEN_ROAD_SCHEMATIC/" +
+            this.getWorldName() + "/" + this.getId())).exists()) {
+            root = MainUtil.getFile(PlotSquared.get().IMP.getDirectory(),
+                "schematics/GEN_ROAD_SCHEMATIC/" + this.getWorldName());
+        }
+
         File schematic1File = new File(root, "sideroad.schem");
         if (!schematic1File.exists())
             schematic1File = new File(root, "sideroad.schematic");
@@ -272,37 +280,8 @@ public class HybridPlotWorld extends ClassicPlotWorld {
                         (short) (z + shift + oddshift + centerShiftZ), biome);
                 }
             }
-/*            HashMap<BlockLoc, CompoundTag> items = schematic3.getTiles();
-            if (!items.isEmpty()) {
-                this.G_SCH_STATE = new HashMap<>();
-                outer:
-                for (Map.Entry<BlockLoc, CompoundTag> entry : items.entrySet()) {
-                    BlockLoc loc = entry.getKey();
-                    short x = (short) (loc.x + shift + oddshift + centerShiftX);
-                    short z = (short) (loc.z + shift + oddshift + centerShiftZ);
-                    short y = (short) (loc.y + this.PLOT_HEIGHT);
-                    int pair = MathMan.pair(x, z);
-                    HashMap<Integer, CompoundTag> existing = this.G_SCH_STATE.get(pair);
-                    if (existing == null) {
-                        existing = new HashMap<>();
-                        this.G_SCH_STATE.put(pair, existing);
-                    }
-                    existing.put((int) y, entry.getValue());
 
-                    CompoundTag tag = entry.getValue();
+            PlotSquared.debug(Captions.PREFIX + "&3 - plot schematic: &7"  + schematic3File.getPath());
-                    Map<String, Tag> map = ReflectionUtils.getMap(tag.getValue());
-                    for (int i = 1; i <= 4; i++) {
-                        String ln = tag.getString("Line" + i);
-                        if (ln == null || ln.length() > 11)
-                            continue outer;
-                    }
-                    SIGN_LOCATION =
-                        new Location(worldname, loc.x + centerShiftX, this.PLOT_HEIGHT + loc.y,
-                            loc.z + centerShiftZ);
-                    ALLOW_SIGNS = true;
-                    continue outer;
-                }
-            }*/
         }
         if (schematic1 == null || schematic2 == null || this.ROAD_WIDTH == 0) {
             PlotSquared.debug(Captions.PREFIX + "&3 - schematic: &7false");

Core/src/main/java/com/plotsquared/core/plot/PlotArea.java

@@ -1023,7 +1023,7 @@ public abstract class PlotArea {
      * @return true if plot signs are allow, false otherwise.
      */
     public boolean allowSigns() {
-        return allowSigns;
+        return allowSigns && (this.plots.size() > 1) /* Do not generate signs for single plots */;
     }
 
     /**

Core/src/main/java/com/plotsquared/core/util/ChunkManager.java

@@ -52,7 +52,7 @@ public abstract class ChunkManager {
     public static void setChunkInPlotArea(RunnableVal<ScopedLocalBlockQueue> force,
         RunnableVal<ScopedLocalBlockQueue> add, String world, BlockVector2 loc) {
         LocalBlockQueue queue = GlobalBlockQueue.IMP.getNewQueue(world, false);
-        if (PlotSquared.get().isAugmented(world)) {
+        if (PlotSquared.get().isAugmented(world) && PlotSquared.get().isNonStandardGeneration(world, loc)) {
             int blockX = loc.getX() << 4;
             int blockZ = loc.getZ() << 4;
             ScopedLocalBlockQueue scoped =