chore: Use correct URL

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

@@ -65,7 +65,6 @@ import net.kyori.adventure.text.minimessage.Template;
 import org.bukkit.Bukkit;
 import org.bukkit.GameMode;
 import org.bukkit.Material;
-import org.bukkit.Tag;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
 import org.bukkit.block.BlockState;
@@ -107,20 +106,11 @@ import org.checkerframework.checker.nullness.qual.NonNull;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Objects;
-import java.util.Set;
 import java.util.UUID;
 
 @SuppressWarnings("unused")
 public class BlockEventListener implements Listener {
 
-    private static final Set<Material> PISTONS = Set.of(
-            Material.PISTON,
-            Material.STICKY_PISTON
-    );
-    private static final Set<Material> PHYSICS_BLOCKS = Set.of(
-            Material.TURTLE_EGG,
-            Material.TURTLE_SPAWN_EGG
-    );
     private final PlotAreaManager plotAreaManager;
     private final WorldEdit worldEdit;
 
@@ -226,31 +216,48 @@ public class BlockEventListener implements Listener {
             plot.debug("Prevented block physics and resent block change because disable-physics = true");
             return;
         }
-        if (event.getChangedType() == Material.COMPARATOR) {
+        switch (event.getChangedType()) {
-            if (!plot.getFlag(RedstoneFlag.class)) {
+            case COMPARATOR: {
-                event.setCancelled(true);
+                if (!plot.getFlag(RedstoneFlag.class)) {
-                plot.debug("Prevented comparator update because redstone = false");
-            }
-            return;
-        }
-        if (PHYSICS_BLOCKS.contains(event.getChangedType())) {
-            if (plot.getFlag(DisablePhysicsFlag.class)) {
-                event.setCancelled(true);
-                plot.debug("Prevented block physics because disable-physics = true");
-            }
-            return;
-        }
-        if (Settings.Redstone.DETECT_INVALID_EDGE_PISTONS) {
-            if (PISTONS.contains(block.getType())) {
-                org.bukkit.block.data.Directional piston = (org.bukkit.block.data.Directional) block.getBlockData();
-                final BlockFace facing = piston.getFacing();
-                location = location.add(facing.getModX(), facing.getModY(), facing.getModZ());
-                Plot newPlot = area.getOwnedPlotAbs(location);
-                if (!plot.equals(newPlot)) {
                     event.setCancelled(true);
-                    plot.debug("Prevented piston update because of invalid edge piston detection");
+                    plot.debug("Prevented comparator update because redstone = false");
                 }
+                return;
             }
+            case ANVIL:
+            case DRAGON_EGG:
+            case GRAVEL:
+            case SAND:
+            case TURTLE_EGG:
+            case TURTLE_HELMET:
+            case TURTLE_SPAWN_EGG: {
+                if (plot.getFlag(DisablePhysicsFlag.class)) {
+                    event.setCancelled(true);
+                    plot.debug("Prevented block physics because disable-physics = true");
+                }
+                return;
+            }
+            default:
+                if (Settings.Redstone.DETECT_INVALID_EDGE_PISTONS) {
+                    switch (block.getType()) {
+                        case PISTON, STICKY_PISTON -> {
+                            org.bukkit.block.data.Directional piston = (org.bukkit.block.data.Directional) block.getBlockData();
+                            switch (piston.getFacing()) {
+                                case EAST -> location = location.add(1, 0, 0);
+                                case SOUTH -> location = location.add(-1, 0, 0);
+                                case WEST -> location = location.add(0, 0, 1);
+                                case NORTH -> location = location.add(0, 0, -1);
+                            }
+                            Plot newPlot = area.getOwnedPlotAbs(location);
+                            if (!plot.equals(newPlot)) {
+                                event.setCancelled(true);
+                                plot.debug("Prevented piston update because of invalid edge piston detection");
+                                return;
+                            }
+                        }
+                    }
+                }
+                break;
         }
     }
 
@@ -541,18 +548,21 @@ public class BlockEventListener implements Listener {
             event.setCancelled(true);
             return;
         }
-        if (Tag.SNOW.isTagged(event.getNewState().getType())) {
+        switch (event.getNewState().getType()) {
-            if (!plot.getFlag(SnowFormFlag.class)) {
+            case SNOW:
-                plot.debug("Snow could not form because snow-form = false");
+            case SNOW_BLOCK:
-                event.setCancelled(true);
+                if (!plot.getFlag(SnowFormFlag.class)) {
-            }
+                    plot.debug("Snow could not form because snow-form = false");
-            return;
+                    event.setCancelled(true);
-        }
+                }
-        if (Tag.ICE.isTagged(event.getNewState().getType())) {
+                return;
-            if (!plot.getFlag(IceFormFlag.class)) {
+            case ICE:
-                plot.debug("Ice could not form because ice-form = false");
+            case FROSTED_ICE:
-                event.setCancelled(true);
+            case PACKED_ICE:
-            }
+                if (!plot.getFlag(IceFormFlag.class)) {
+                    plot.debug("Ice could not form because ice-form = false");
+                    event.setCancelled(true);
+                }
         }
     }
 
@@ -573,12 +583,18 @@ public class BlockEventListener implements Listener {
             return;
         }
         Class<? extends BooleanFlag<?>> flag;
-        if (Tag.SNOW.isTagged(event.getNewState().getType())) {
+        switch (event.getNewState().getType()) {
-            flag = SnowFormFlag.class;
+            case SNOW:
-        } else if (Tag.ICE.isTagged(event.getNewState().getType())) {
+            case SNOW_BLOCK:
-            flag = IceFormFlag.class;
+                flag = SnowFormFlag.class;
-        } else {
+                break;
-            return;
+            case ICE:
+            case FROSTED_ICE:
+            case PACKED_ICE:
+                flag = IceFormFlag.class;
+                break;
+            default:
+                return; // other blocks are ignored by this event
         }
         boolean allowed = plot.getFlag(flag);
         Entity entity = event.getEntity();
@@ -682,33 +698,50 @@ public class BlockEventListener implements Listener {
             event.setCancelled(true);
             return;
         }
-        Material blockType = block.getType();
+        switch (block.getType()) {
-        if (Tag.ICE.isTagged(blockType)) {
+            case ICE:
-            if (!plot.getFlag(IceMeltFlag.class)) {
+                if (!plot.getFlag(IceMeltFlag.class)) {
-                plot.debug("Ice could not melt because ice-melt = false");
+                    plot.debug("Ice could not melt because ice-melt = false");
-                event.setCancelled(true);
+                    event.setCancelled(true);
-            }
+                }
-            return;
+                break;
-        }
+            case SNOW:
-        if (Tag.SNOW.isTagged(blockType)) {
+                if (!plot.getFlag(SnowMeltFlag.class)) {
-            if (!plot.getFlag(SnowMeltFlag.class)) {
+                    plot.debug("Snow could not melt because snow-melt = false");
-                plot.debug("Snow could not melt because snow-melt = false");
+                    event.setCancelled(true);
-                event.setCancelled(true);
+                }
-            }
+                break;
-            return;
+            case FARMLAND:
-        }
+                if (!plot.getFlag(SoilDryFlag.class)) {
-        if (blockType == Material.FARMLAND) {
+                    plot.debug("Soil could not dry because soil-dry = false");
-            if (!plot.getFlag(SoilDryFlag.class)) {
+                    event.setCancelled(true);
-                plot.debug("Soil could not dry because soil-dry = false");
+                }
-                event.setCancelled(true);
+                break;
-            }
+            case TUBE_CORAL_BLOCK:
-            return;
+            case BRAIN_CORAL_BLOCK:
-        }
+            case BUBBLE_CORAL_BLOCK:
-        if (Tag.CORAL_BLOCKS.isTagged(blockType) || Tag.CORALS.isTagged(blockType)) {
+            case FIRE_CORAL_BLOCK:
-            if (!plot.getFlag(CoralDryFlag.class)) {
+            case HORN_CORAL_BLOCK:
-                plot.debug("Coral could not dry because coral-dry = false");
+            case TUBE_CORAL:
-                event.setCancelled(true);
+            case BRAIN_CORAL:
-            }
+            case BUBBLE_CORAL:
+            case FIRE_CORAL:
+            case HORN_CORAL:
+            case TUBE_CORAL_FAN:
+            case BRAIN_CORAL_FAN:
+            case BUBBLE_CORAL_FAN:
+            case FIRE_CORAL_FAN:
+            case HORN_CORAL_FAN:
+            case BRAIN_CORAL_WALL_FAN:
+            case BUBBLE_CORAL_WALL_FAN:
+            case FIRE_CORAL_WALL_FAN:
+            case HORN_CORAL_WALL_FAN:
+            case TUBE_CORAL_WALL_FAN:
+                if (!plot.getFlag(CoralDryFlag.class)) {
+                    plot.debug("Coral could not dry because coral-dry = false");
+                    event.setCancelled(true);
+                }
+                break;
         }
     }
 

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

@@ -26,7 +26,6 @@ import com.plotsquared.core.plot.Plot;
 import com.plotsquared.core.plot.PlotArea;
 import com.plotsquared.core.plot.flag.implementations.CopperOxideFlag;
 import com.plotsquared.core.plot.flag.implementations.MiscInteractFlag;
-import org.bukkit.Material;
 import org.bukkit.block.Block;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Item;
@@ -40,31 +39,11 @@ import org.bukkit.event.block.BlockReceiveGameEvent;
 
 import java.util.List;
 import java.util.Objects;
-import java.util.Set;
 import java.util.UUID;
 
 @SuppressWarnings("unused")
 public class BlockEventListener117 implements Listener {
 
-    private static final Set<Material> COPPER_OXIDIZING = Set.of(
-            Material.COPPER_BLOCK,
-            Material.EXPOSED_COPPER,
-            Material.WEATHERED_COPPER,
-            Material.OXIDIZED_COPPER,
-            Material.CUT_COPPER,
-            Material.EXPOSED_CUT_COPPER,
-            Material.WEATHERED_CUT_COPPER,
-            Material.OXIDIZED_CUT_COPPER,
-            Material.CUT_COPPER_STAIRS,
-            Material.EXPOSED_CUT_COPPER_STAIRS,
-            Material.WEATHERED_CUT_COPPER_STAIRS,
-            Material.OXIDIZED_CUT_COPPER_STAIRS,
-            Material.CUT_COPPER_SLAB,
-            Material.EXPOSED_CUT_COPPER_SLAB,
-            Material.WEATHERED_CUT_COPPER_SLAB,
-            Material.OXIDIZED_CUT_COPPER_SLAB
-    );
-
     @Inject
     public BlockEventListener117() {
     }
@@ -169,11 +148,27 @@ public class BlockEventListener117 implements Listener {
         if (plot == null) {
             return;
         }
-        if (COPPER_OXIDIZING.contains(event.getNewState().getType())) {
+        switch (event.getNewState().getType()) {
-            if (!plot.getFlag(CopperOxideFlag.class)) {
+            case COPPER_BLOCK:
-                plot.debug("Copper could not oxide because copper-oxide = false");
+            case EXPOSED_COPPER:
-                event.setCancelled(true);
+            case WEATHERED_COPPER:
-            }
+            case OXIDIZED_COPPER:
+            case CUT_COPPER:
+            case EXPOSED_CUT_COPPER:
+            case WEATHERED_CUT_COPPER:
+            case OXIDIZED_CUT_COPPER:
+            case CUT_COPPER_STAIRS:
+            case EXPOSED_CUT_COPPER_STAIRS:
+            case WEATHERED_CUT_COPPER_STAIRS:
+            case OXIDIZED_CUT_COPPER_STAIRS:
+            case CUT_COPPER_SLAB:
+            case EXPOSED_CUT_COPPER_SLAB:
+            case WEATHERED_CUT_COPPER_SLAB:
+            case OXIDIZED_CUT_COPPER_SLAB:
+                if (!plot.getFlag(CopperOxideFlag.class)) {
+                    plot.debug("Copper could not oxide because copper-oxide = false");
+                    event.setCancelled(true);
+                }
         }
     }
 

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

@@ -124,17 +124,17 @@ public class EntitySpawnListener implements Listener {
             return;
         }
         Plot plot = location.getOwnedPlotAbs();
-        EntityType type = entity.getType();
         if (plot == null) {
+            EntityType type = entity.getType();
             if (!area.isMobSpawning()) {
-                if (type == EntityType.PLAYER) {
+                switch (type) {
-                    return;
+                    case DROPPED_ITEM:
-                }
+                        if (Settings.Enabled_Components.KILL_ROAD_ITEMS) {
-                if (type == EntityType.DROPPED_ITEM) {
+                            event.setCancelled(true);
-                    if (Settings.Enabled_Components.KILL_ROAD_ITEMS) {
+                            return;
-                        event.setCancelled(true);
+                        }
-                    }
+                    case PLAYER:
-                    return;
+                        return;
                 }
                 if (type.isAlive()) {
                     event.setCancelled(true);
@@ -148,16 +148,15 @@ public class EntitySpawnListener implements Listener {
         if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
             event.setCancelled(true);
         }
-        if (type == EntityType.ENDER_CRYSTAL) {
+        switch (entity.getType()) {
-            if (BukkitEntityUtil.checkEntity(entity, plot)) {
+            case ENDER_CRYSTAL:
-                event.setCancelled(true);
+                if (BukkitEntityUtil.checkEntity(entity, plot)) {
-            }
+                    event.setCancelled(true);
-            return;
+                }
-        }
+            case SHULKER:
-        if (type == EntityType.SHULKER) {
+                if (!entity.hasMetadata("shulkerPlot")) {
-            if (!entity.hasMetadata("shulkerPlot")) {
+                    entity.setMetadata("shulkerPlot", new FixedMetadataValue((Plugin) PlotSquared.platform(), plot.getId()));
-                entity.setMetadata("shulkerPlot", new FixedMetadataValue((Plugin) PlotSquared.platform(), plot.getId()));
+                }
-            }
         }
     }
 

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

@@ -230,15 +230,15 @@ public class PaperListener implements Listener {
         if (plot == null) {
             EntityType type = event.getType();
             if (!area.isMobSpawning()) {
-                if (type == EntityType.PLAYER) {
+                switch (type) {
-                    return;
+                    case DROPPED_ITEM:
-                }
+                        if (Settings.Enabled_Components.KILL_ROAD_ITEMS) {
-                if (type == EntityType.DROPPED_ITEM) {
+                            event.setShouldAbortSpawn(true);
-                    if (Settings.Enabled_Components.KILL_ROAD_ITEMS) {
+                            event.setCancelled(true);
-                        event.setShouldAbortSpawn(true);
+                            return;
-                        event.setCancelled(true);
+                        }
-                    }
+                    case PLAYER:
-                    return;
+                        return;
                 }
                 if (type.isAlive()) {
                     event.setShouldAbortSpawn(true);

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

@@ -82,7 +82,6 @@ import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.FluidCollisionMode;
 import org.bukkit.Material;
-import org.bukkit.Tag;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
 import org.bukkit.block.BlockState;
@@ -160,20 +159,6 @@ import java.util.regex.Pattern;
 @SuppressWarnings("unused")
 public class PlayerEventListener extends PlotListener implements Listener {
 
-    private static final Set<Material> MINECARTS = Set.of(
-            Material.MINECART,
-            Material.TNT_MINECART,
-            Material.CHEST_MINECART,
-            Material.COMMAND_BLOCK_MINECART,
-            Material.FURNACE_MINECART,
-            Material.HOPPER_MINECART
-    );
-    private static final Set<Material> BOOKS = Set.of(
-            Material.BOOK,
-            Material.KNOWLEDGE_BOOK,
-            Material.WRITABLE_BOOK,
-            Material.WRITTEN_BOOK
-    );
     private final EventDispatcher eventDispatcher;
     private final WorldEdit worldEdit;
     private final PlotAreaManager plotAreaManager;
@@ -845,10 +830,10 @@ public class PlayerEventListener extends PlotListener implements Listener {
         if ((slot > 8) || !event.getEventName().equals("InventoryCreativeEvent")) {
             return;
         }
-        ItemStack oldItem = inv.getItemInHand();
+        ItemStack current = inv.getItemInHand();
-        ItemMeta oldMeta = oldItem.getItemMeta();
         ItemStack newItem = event.getCursor();
         ItemMeta newMeta = newItem.getItemMeta();
+        ItemMeta oldMeta = newItem.getItemMeta();
 
         if (event.getClick() == ClickType.CREATIVE) {
             final Plot plot = pp.getCurrentPlot();
@@ -888,26 +873,34 @@ public class PlayerEventListener extends PlotListener implements Listener {
                 oldLore = lore.toString();
             }
         }
-        Material itemType = newItem.getType();
+        if (!"[(+NBT)]".equals(newLore) || (current.equals(newItem) && newLore.equals(oldLore))) {
-        if (!"[(+NBT)]".equals(newLore) || (oldItem.equals(newItem) && newLore.equals(oldLore))) {
+            switch (newItem.getType()) {
-            if (newMeta == null || (itemType != Material.LEGACY_BANNER && itemType != Material.PLAYER_HEAD)) {
+                case LEGACY_BANNER:
-                return;
+                case PLAYER_HEAD:
+                    if (newMeta != null) {
+                        break;
+                    }
+                default:
+                    return;
             }
         }
         Block block = player.getTargetBlock(null, 7);
         org.bukkit.block.BlockState state = block.getState();
         Material stateType = state.getType();
+        Material itemType = newItem.getType();
         if (stateType != itemType) {
-            if (stateType == Material.LEGACY_WALL_BANNER || stateType == Material.LEGACY_STANDING_BANNER) {
+            switch (stateType) {
-                if (itemType != Material.LEGACY_BANNER) {
+                case LEGACY_STANDING_BANNER:
+                case LEGACY_WALL_BANNER:
+                    if (itemType == Material.LEGACY_BANNER) {
+                        break;
+                    }
+                case LEGACY_SKULL:
+                    if (itemType == Material.LEGACY_SKULL_ITEM) {
+                        break;
+                    }
+                default:
                     return;
-                }
-            } else if (stateType == Material.LEGACY_SKULL) {
-                if (itemType != Material.LEGACY_SKULL_ITEM) {
-                    return;
-                }
-            } else {
-                return;
             }
         }
         Location location = BukkitUtil.adapt(state.getLocation());
@@ -946,7 +939,7 @@ public class PlayerEventListener extends PlotListener implements Listener {
             }
         }
         if (cancelled) {
-            if ((oldItem.getType() == newItem.getType()) && (oldItem.getDurability() == newItem
+            if ((current.getType() == newItem.getType()) && (current.getDurability() == newItem
                     .getDurability())) {
                 event.setCursor(
                         new ItemStack(newItem.getType(), newItem.getAmount(), newItem.getDurability()));
@@ -1133,21 +1126,14 @@ public class PlayerEventListener extends PlotListener implements Listener {
                     //Allow all players to eat while also allowing the block place event ot be fired
                     return;
                 }
-                if (type == Material.ARMOR_STAND) {
+                switch (type) {
-                    location = BukkitUtil.adapt(block.getRelative(event.getBlockFace()).getLocation());
+                    case ACACIA_BOAT, BIRCH_BOAT, CHEST_MINECART, COMMAND_BLOCK_MINECART, DARK_OAK_BOAT, FURNACE_MINECART, HOPPER_MINECART, JUNGLE_BOAT, MINECART, OAK_BOAT, SPRUCE_BOAT, TNT_MINECART -> eventType = PlayerBlockEventType.PLACE_VEHICLE;
-                    eventType = PlayerBlockEventType.PLACE_MISC;
+                    case FIREWORK_ROCKET, FIREWORK_STAR -> eventType = PlayerBlockEventType.SPAWN_MOB;
-                }
+                    case BOOK, KNOWLEDGE_BOOK, WRITABLE_BOOK, WRITTEN_BOOK -> eventType = PlayerBlockEventType.READ;
-                if (Tag.ITEMS_BOATS.isTagged(type) || MINECARTS.contains(type)) {
+                    case ARMOR_STAND -> {
-                    eventType = PlayerBlockEventType.PLACE_VEHICLE;
+                        location = BukkitUtil.adapt(block.getRelative(event.getBlockFace()).getLocation());
-                    break;
+                        eventType = PlayerBlockEventType.PLACE_MISC;
-                }
+                    }
-                if (type == Material.FIREWORK_ROCKET || type == Material.FIREWORK_STAR) {
-                    eventType = PlayerBlockEventType.SPAWN_MOB;
-                    break;
-                }
-                if (BOOKS.contains(type)) {
-                    eventType = PlayerBlockEventType.READ;
-                    break;
                 }
                 break;
             }

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

@@ -74,9 +74,6 @@ 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;
@@ -269,57 +266,33 @@ 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 worldGenHeight = getMaxGenHeight() - getMinGenHeight() + 1;
+        int worldHeight = getMaxGenHeight() - getMinGenHeight() + 1;
-
-        int maxSchematicHeight = 0;
 
         // SCHEM_Y should be normalised to the plot "start" height
         if (schematic3 != null) {
-            if ((maxSchematicHeight = schematic3.getClipboard().getDimensions().getY()) == worldGenHeight) {
+            if (schematic3.getClipboard().getDimensions().getY() == worldHeight) {
-                SCHEM_Y = getMinGenHeight();
+                SCHEM_Y = plotY = 0;
-                plotY = 0;
             } else if (!Settings.Schematics.PASTE_ON_TOP) {
-                SCHEM_Y = getMinBuildHeight();
+                SCHEM_Y = plotY = getMinBuildHeight() - getMinGenHeight();
-                plotY = 0;
             }
         }
 
         if (schematic1 != null) {
-            if ((maxSchematicHeight = Math.max(
+            if (schematic1.getClipboard().getDimensions().getY() == worldHeight) {
-                    schematic1.getClipboard().getDimensions().getY(),
+                SCHEM_Y = roadY = getMinGenHeight();
-                    maxSchematicHeight
+                if (schematic3 != null && schematic3.getClipboard().getDimensions().getY() != worldHeight
-            )) == worldGenHeight) {
+                        && !Settings.Schematics.PASTE_ON_TOP) {
-                SCHEM_Y = getMinGenHeight();
+                    plotY = PLOT_HEIGHT;
-                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) {
-                if (SCHEM_Y == getMinGenHeight()) { // Only possible if plot schematic is enabled
+                SCHEM_Y = roadY = getMinBuildHeight();
-                    // Plot is still the lowest schematic, normalize roadY to it
+                if (schematic3 != null && schematic3.getClipboard().getDimensions().getY() != worldHeight
-                    roadY = getMinBuildHeight() - getMinGenHeight();
+                        && !Settings.Schematics.PASTE_ON_TOP) {
-                } else if (schematic3 != null) {
+                    plotY = PLOT_HEIGHT;
-                    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.
                 }
             }
         }
@@ -357,15 +330,17 @@ public class HybridPlotWorld extends ClassicPlotWorld {
                                 y + min.getBlockY(),
                                 z + min.getBlockZ()
                         ));
-                        schem3PopulationNeeded |= id.hasNbtData();
+                        if (!id.getBlockType().getMaterial().isAir()) {
-                        addOverlayBlock(
+                            schem3PopulationNeeded |= id.hasNbtData();
-                                (short) (x + shift + oddshift + centerShiftX),
+                            addOverlayBlock(
-                                (short) (y + plotY),
+                                    (short) (x + shift + oddshift + centerShiftX),
-                                (short) (z + shift + oddshift + centerShiftZ),
+                                    (short) (y + plotY),
-                                id,
+                                    (short) (z + shift + oddshift + centerShiftZ),
-                                false,
+                                    id,
-                                maxSchematicHeight
+                                    false,
-                        );
+                                    h3
+                            );
+                        }
                     }
                     if (blockArrayClipboard3.hasBiomes()) {
                         BiomeType biome = blockArrayClipboard3.getBiome(BlockVector2.at(
@@ -415,23 +390,18 @@ public class HybridPlotWorld extends ClassicPlotWorld {
                             y + min.getBlockY(),
                             z + min.getBlockZ()
                     ));
-                    schem1PopulationNeeded |= id.hasNbtData();
+                    if (!id.getBlockType().getMaterial().isAir()) {
-                    addOverlayBlock(
+                        schem1PopulationNeeded |= id.hasNbtData();
-                            (short) (x - shift),
+                        addOverlayBlock((short) (x - shift), (short) (y + roadY), (short) (z + shift + oddshift), id, false, h1);
-                            (short) (y + roadY),
+                        addOverlayBlock(
-                            (short) (z + shift + oddshift),
+                                (short) (z + shift + oddshift),
-                            id,
+                                (short) (y + roadY),
-                            false,
+                                (short) (shift - x + (oddshift - 1)),
-                            maxSchematicHeight
+                                id,
-                    );
+                                true,
-                    addOverlayBlock(
+                                h1
-                            (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()));
@@ -459,15 +429,10 @@ public class HybridPlotWorld extends ClassicPlotWorld {
                             y + min.getBlockY(),
                             z + min.getBlockZ()
                     ));
-                    schem2PopulationNeeded |= id.hasNbtData();
+                    if (!id.getBlockType().getMaterial().isAir()) {
-                    addOverlayBlock(
+                        schem2PopulationNeeded |= id.hasNbtData();
-                            (short) (x - shift),
+                        addOverlayBlock((short) (x - shift), (short) (y + roadY), (short) (z - shift), id, false, h2);
-                            (short) (y + roadY),
+                    }
-                            (short) (z - shift),
-                            id,
-                            false,
-                            maxSchematicHeight
-                    );
                 }
                 if (blockArrayClipboard2.hasBiomes()) {
                     BiomeType biome = blockArrayClipboard2.getBiome(BlockVector2.at(x + min.getBlockX(), z + min.getBlockZ()));
@@ -477,10 +442,6 @@ 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;
@@ -507,10 +468,6 @@ 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;

gradle/libs.versions.toml

@@ -1,7 +1,7 @@
 [versions]
 # Platform expectations
 paper = "1.18.1-R0.1-SNAPSHOT"
-checker-qual = "3.22.2"
+checker-qual = "3.22.0"
 guice = "5.1.0"
 spotbugs = "4.7.0"