Minor cleanup of the plot analyze code

- No need to wrap the final analysis into another async method. It's already contained in an async task
 - Don't overstretch a chunk bounday when setting blocks to newBlocks array

Bukkit/build.gradle.kts

@@ -105,6 +105,5 @@ tasks {
         opt.links("https://jd.adventure.kyori.net/api/4.9.3/")
         opt.links("https://google.github.io/guice/api-docs/" + libs.guice.get().versionConstraint.toString() + "/javadoc/")
         opt.links("https://checkerframework.org/api/")
-        opt.encoding("UTF-8")
     }
 }

Bukkit/src/main/java/com/plotsquared/bukkit/listener/ProjectileEventListener.java

@@ -89,7 +89,7 @@ public class ProjectileEventListener implements Listener {
         }
     }
 
-    @EventHandler(ignoreCancelled = true)
+    @EventHandler
     public void onProjectileLaunch(ProjectileLaunchEvent event) {
         Projectile entity = event.getEntity();
         ProjectileSource shooter = entity.getShooter();

Core/build.gradle.kts

@@ -64,6 +64,5 @@ tasks {
         opt.links("https://google.github.io/guice/api-docs/" + libs.guice.get().versionConstraint.toString() + "/javadoc/")
         opt.links("https://checkerframework.org/api/")
         opt.links("https://javadoc.io/doc/com.intellectualsites.informative-annotations/informative-annotations/latest/")
-        opt.encoding("UTF-8")
     }
 }

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

@@ -462,7 +462,6 @@ public final class FlagCommand extends Command {
             return;
         }
         final Plot plot = player.getLocation().getPlotAbs();
-        final PlotFlag<?, ?> flagWithOldValue = plot.getFlagContainer().getFlag(flag.getClass());
         PlotFlagRemoveEvent event = eventDispatcher.callFlagRemove(flag, plot);
         if (event.getEventResult() == Result.DENY) {
             player.sendMessage(
@@ -507,7 +506,7 @@ public final class FlagCommand extends Command {
                     if (plot.removeFlag(flag)) {
                         player.sendMessage(TranslatableCaption.of("flag.flag_removed"), Template.of("flag", args[0]), Template.of(
                                 "value",
-                                String.valueOf(flagWithOldValue)
+                                String.valueOf(flag)
                         ));
                         return;
                     } else {
@@ -545,7 +544,7 @@ public final class FlagCommand extends Command {
         }
         player.sendMessage(TranslatableCaption.of("flag.flag_removed"), Template.of("flag", args[0]), Template.of(
                 "value",
-                String.valueOf(flagWithOldValue)
+                String.valueOf(flag)
         ));
     }
 

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

@@ -21,7 +21,6 @@ package com.plotsquared.core.generator;
 import com.google.inject.Inject;
 import com.google.inject.assistedinject.Assisted;
 import com.intellectualsites.annotations.DoNotUse;
-import com.intellectualsites.annotations.NotPublic;
 import com.plotsquared.core.PlotSquared;
 import com.plotsquared.core.configuration.ConfigurationSection;
 import com.plotsquared.core.configuration.Settings;
@@ -75,6 +74,9 @@ public class HybridPlotWorld extends ClassicPlotWorld {
     public short PATH_WIDTH_UPPER;
     public HashMap<Integer, BaseBlock[]> G_SCH;
     public HashMap<Integer, BiomeType> G_SCH_B;
+    /**
+     * The Y level at which schematic generation will start, lowest of either road or plot schematic generation.
+     */
     public int SCHEM_Y;
     private Location SIGN_LOCATION;
     private File root = null;
@@ -267,33 +269,57 @@ public class HybridPlotWorld extends ClassicPlotWorld {
         int oddshift = (this.ROAD_WIDTH & 1);
 
         SCHEM_Y = schematicStartHeight();
+
+        // plotY and roadY are important to allow plot and/or road schematic "overflow" into each other without causing AIOOB
+        //  exceptions when attempting either to set blocks to, or get block from G_SCH
+        // Default plot schematic start height, normalized to the minimum height schematics are pasted from.
         int plotY = PLOT_HEIGHT - SCHEM_Y;
         int minRoadWall = Settings.Schematics.USE_WALL_IN_ROAD_SCHEM_HEIGHT ? Math.min(ROAD_HEIGHT, WALL_HEIGHT) : ROAD_HEIGHT;
+        // Default road schematic start height, normalized to the minimum height schematics are pasted from.
         int roadY = minRoadWall - SCHEM_Y;
 
-        int worldHeight = getMaxGenHeight() - getMinGenHeight() + 1;
+        int worldGenHeight = getMaxGenHeight() - getMinGenHeight() + 1;
+
+        int maxSchematicHeight = 0;
 
         // SCHEM_Y should be normalised to the plot "start" height
         if (schematic3 != null) {
-            if (schematic3.getClipboard().getDimensions().getY() == worldHeight) {
+            if ((maxSchematicHeight = schematic3.getClipboard().getDimensions().getY()) == worldGenHeight) {
-                SCHEM_Y = plotY = 0;
+                SCHEM_Y = getMinGenHeight();
+                plotY = 0;
             } else if (!Settings.Schematics.PASTE_ON_TOP) {
-                SCHEM_Y = plotY = getMinBuildHeight() - getMinGenHeight();
+                SCHEM_Y = getMinBuildHeight();
+                plotY = 0;
             }
         }
 
         if (schematic1 != null) {
-            if (schematic1.getClipboard().getDimensions().getY() == worldHeight) {
+            if ((maxSchematicHeight = Math.max(
-                SCHEM_Y = roadY = getMinGenHeight();
+                    schematic1.getClipboard().getDimensions().getY(),
-                if (schematic3 != null && schematic3.getClipboard().getDimensions().getY() != worldHeight
+                    maxSchematicHeight
-                        && !Settings.Schematics.PASTE_ON_TOP) {
+            )) == worldGenHeight) {
-                    plotY = PLOT_HEIGHT;
+                SCHEM_Y = getMinGenHeight();
+                roadY = 0; // Road is the lowest schematic
+                if (schematic3 != null && schematic3.getClipboard().getDimensions().getY() != worldGenHeight) {
+                    // Road is the lowest schematic. Normalize plotY to it.
+                    if (Settings.Schematics.PASTE_ON_TOP) {
+                        plotY = PLOT_HEIGHT - getMinGenHeight();
+                    } else {
+                        plotY = getMinBuildHeight() - getMinGenHeight();
+                    }
                 }
             } else if (!Settings.Schematics.PASTE_ROAD_ON_TOP) {
-                SCHEM_Y = roadY = getMinBuildHeight();
+                if (SCHEM_Y == getMinGenHeight()) { // Only possible if plot schematic is enabled
-                if (schematic3 != null && schematic3.getClipboard().getDimensions().getY() != worldHeight
+                    // Plot is still the lowest schematic, normalize roadY to it
-                        && !Settings.Schematics.PASTE_ON_TOP) {
+                    roadY = getMinBuildHeight() - getMinGenHeight();
-                    plotY = PLOT_HEIGHT;
+                } else if (schematic3 != null) {
+                    SCHEM_Y = getMinBuildHeight();
+                    roadY = 0;// Road is the lowest schematic
+                    if (Settings.Schematics.PASTE_ON_TOP) {
+                        // Road is the lowest schematic. Normalize plotY to it.
+                        plotY = PLOT_HEIGHT - getMinBuildHeight();
+                    }
+                    // If plot schematic is not paste-on-top, it will be from min build height thus plotY = 0 as well already.
                 }
             }
         }
@@ -331,17 +357,15 @@ public class HybridPlotWorld extends ClassicPlotWorld {
                                 y + min.getBlockY(),
                                 z + min.getBlockZ()
                         ));
-                        if (!id.getBlockType().getMaterial().isAir()) {
+                        schem3PopulationNeeded |= id.hasNbtData();
-                            schem3PopulationNeeded |= id.hasNbtData();
+                        addOverlayBlock(
-                            addOverlayBlock(
+                                (short) (x + shift + oddshift + centerShiftX),
-                                    (short) (x + shift + oddshift + centerShiftX),
+                                (short) (y + plotY),
-                                    (short) (y + plotY),
+                                (short) (z + shift + oddshift + centerShiftZ),
-                                    (short) (z + shift + oddshift + centerShiftZ),
+                                id,
-                                    id,
+                                false,
-                                    false,
+                                maxSchematicHeight
-                                    h3
+                        );
-                            );
-                        }
                     }
                     if (blockArrayClipboard3.hasBiomes()) {
                         BiomeType biome = blockArrayClipboard3.getBiome(BlockVector2.at(
@@ -391,18 +415,23 @@ public class HybridPlotWorld extends ClassicPlotWorld {
                             y + min.getBlockY(),
                             z + min.getBlockZ()
                     ));
-                    if (!id.getBlockType().getMaterial().isAir()) {
+                    schem1PopulationNeeded |= id.hasNbtData();
-                        schem1PopulationNeeded |= id.hasNbtData();
+                    addOverlayBlock(
-                        addOverlayBlock((short) (x - shift), (short) (y + roadY), (short) (z + shift + oddshift), id, false, h1);
+                            (short) (x - shift),
-                        addOverlayBlock(
+                            (short) (y + roadY),
-                                (short) (z + shift + oddshift),
+                            (short) (z + shift + oddshift),
-                                (short) (y + roadY),
+                            id,
-                                (short) (shift - x + (oddshift - 1)),
+                            false,
-                                id,
+                            maxSchematicHeight
-                                true,
+                    );
-                                h1
+                    addOverlayBlock(
-                        );
+                            (short) (z + shift + oddshift),
-                    }
+                            (short) (y + roadY),
+                            (short) (shift - x + (oddshift - 1)),
+                            id,
+                            true,
+                            maxSchematicHeight
+                    );
                 }
                 if (blockArrayClipboard1.hasBiomes()) {
                     BiomeType biome = blockArrayClipboard1.getBiome(BlockVector2.at(x + min.getBlockX(), z + min.getBlockZ()));
@@ -430,10 +459,15 @@ public class HybridPlotWorld extends ClassicPlotWorld {
                             y + min.getBlockY(),
                             z + min.getBlockZ()
                     ));
-                    if (!id.getBlockType().getMaterial().isAir()) {
+                    schem2PopulationNeeded |= id.hasNbtData();
-                        schem2PopulationNeeded |= id.hasNbtData();
+                    addOverlayBlock(
-                        addOverlayBlock((short) (x - shift), (short) (y + roadY), (short) (z - shift), id, false, h2);
+                            (short) (x - shift),
-                    }
+                            (short) (y + roadY),
+                            (short) (z - shift),
+                            id,
+                            false,
+                            maxSchematicHeight
+                    );
                 }
                 if (blockArrayClipboard2.hasBiomes()) {
                     BiomeType biome = blockArrayClipboard2.getBiome(BlockVector2.at(x + min.getBlockX(), z + min.getBlockZ()));
@@ -443,6 +477,10 @@ public class HybridPlotWorld extends ClassicPlotWorld {
         }
     }
 
+    /**
+     * @deprecated This method should not be available for public API usage and will be made private.
+     */
+    @Deprecated(forRemoval = true, since = "TODO")
     public void addOverlayBlock(short x, short y, short z, BaseBlock id, boolean rotate, int height) {
         if (z < 0) {
             z += this.SIZE;
@@ -460,7 +498,7 @@ public class HybridPlotWorld extends ClassicPlotWorld {
         int pair = MathMan.pair(x, z);
         BaseBlock[] existing = this.G_SCH.computeIfAbsent(pair, k -> new BaseBlock[height]);
         if (y >= height) {
-            if (y > lastOverlayHeightError) {
+            if (y != lastOverlayHeightError) {
                 lastOverlayHeightError = y;
                 LOGGER.error(String.format("Error adding overlay block. `y > height`. y=%s, height=%s", y, height));
             }
@@ -469,6 +507,10 @@ public class HybridPlotWorld extends ClassicPlotWorld {
         existing[y] = id;
     }
 
+    /**
+     * @deprecated This method should not be available for public API usage and will be made private.
+     */
+    @Deprecated(forRemoval = true, since = "TODO")
     public void addOverlayBiome(short x, short z, BiomeType id) {
         if (z < 0) {
             z += this.SIZE;

Core/src/main/java/com/plotsquared/core/location/Location.java

@@ -313,7 +313,7 @@ public sealed class Location extends BlockLoc implements Comparable<Location> pe
     /**
      * Get the absolute {@link Plot}, if any, that contains this location
      *
-     * @return (Absolute) plot containing the location, or {@code null}
+     * @return (Absolute) plot containing the location, or {code null}
      */
     public @Nullable Plot getPlotAbs() {
         final PlotArea area = this.getPlotArea();
@@ -327,7 +327,7 @@ public sealed class Location extends BlockLoc implements Comparable<Location> pe
     /**
      * Get the {@link Plot}, if any, that contains this location
      *
-     * @return plot containing the location, or {@code null}
+     * @return plot containing the location, or {code null}
      */
     public @Nullable Plot getPlot() {
         final PlotArea area = this.getPlotArea();

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

@@ -643,7 +643,7 @@ public abstract class PlotArea {
      * @param player Player to check
      * @param y      y height to check
      * @return true if outside build area with no permissions
-     * @since 6.9.1
+     * @since TODO
      */
     public boolean notifyIfOutsideBuildArea(PlotPlayer<?> player, int y) {
         if (!buildRangeContainsY(y) && !Permissions.hasPermission(player, Permission.PERMISSION_ADMIN_BUILD_HEIGHT_LIMIT)) {

build.gradle.kts

@@ -19,7 +19,7 @@ plugins {
 }
 
 group = "com.plotsquared"
-version = "6.9.2"
+version = "6.9.1-SNAPSHOT"
 
 subprojects {
     group = rootProject.group
@@ -65,7 +65,7 @@ subprojects {
     }
 
     dependencies {
-        implementation(platform("com.intellectualsites.bom:bom-1.18.x:1.9"))
+        implementation(platform("com.intellectualsites.bom:bom-1.18.x:1.7"))
     }
 
     dependencies {

gradle/libs.versions.toml

@@ -2,11 +2,11 @@
 # Platform expectations
 paper = "1.18.1-R0.1-SNAPSHOT"
 guice = "5.1.0"
-spotbugs = "4.7.1"
+spotbugs = "4.7.0"
 
 # Plugins
 worldedit = "7.2.10"
-placeholderapi = "2.11.2"
+placeholderapi = "2.11.1"
 luckperms = "5.4"
 essentialsx = "2.19.4"
 mvdwapi = "3.1.1"

renovate.json

@@ -3,6 +3,10 @@
     "config:base",
     ":disableDependencyDashboard"
   ],
+  "timezone": "Europe/Berlin",
+  "schedule": [
+    "every monday"
+  ],
   "labels": ["Renovate"],
   "commitMessagePrefix": "build: ",
   "rebaseWhen": "conflicted"