recovered original functionality

Author: david

src/main/java/net/onelitefeather/bettergopaint/objects/brush/FractureBrush.java

@@ -46,15 +46,15 @@ public void paint(
     ) {
         performEdit(player, session -> {
             Stream<Block> blocks = Sphere.getBlocksInRadius(location, brushSettings.size(), null, false);
-            blocks.filter(block -> passesDefaultChecks(brushSettings, player, block))
+            blocks.filter(block -> passesMaskCheck(brushSettings, block))
                     .filter(block -> Height.getAverageHeightDiffFracture(
                             block.getLocation(),
-                            Height.getHeight(block.getLocation()),
+                            Height.getNearestNonEmptyBlock(block.getLocation()),
                             1
                     ) >= 0.1)
                     .filter(block -> Height.getAverageHeightDiffFracture(
                             block.getLocation(),
-                            Height.getHeight(block.getLocation()),
+                            Height.getNearestNonEmptyBlock(block.getLocation()),
                             brushSettings.fractureDistance()
                     ) >= 0.1)
                     .forEach(block -> setBlock(session, block, brushSettings.randomBlock()));

src/main/java/net/onelitefeather/bettergopaint/utils/Height.java

@@ -19,50 +19,88 @@
 package net.onelitefeather.bettergopaint.utils;
 
 import org.bukkit.Location;
+import org.bukkit.block.Block;
 import org.jetbrains.annotations.NotNull;
 
 public class Height {
 
-    public static int getHeight(@NotNull Location location) {
-        return location.getWorld().getHighestBlockYAt(location);
+    /**
+     * Gets the height of the nearest non-empty block at a given location.
+     *
+     * @param location the location to check
+     * @return the height of the nearest non-empty block at the location
+     */
+    public static int getNearestNonEmptyBlock(@NotNull Location location) {
+        if (location.getBlock().getType().isEmpty()) {
+            for (int y = location.getBlockY(); y >= location.getWorld().getMinHeight(); y--) {
+                Block block = location.getWorld().getBlockAt(location.getBlockX(), y, location.getBlockZ());
+                if (!block.isEmpty()) {
+                    return y + 1;
+                }
+            }
+            return location.getWorld().getMinHeight();
+        } else {
+            for (int y = location.getBlockY(); y <= location.getWorld().getMaxHeight(); y++) {
+                Block block = location.getWorld().getBlockAt(location.getBlockX(), y, location.getBlockZ());
+                if (block.isEmpty()) {
+                    return y;
+                }
+            }
+            return location.getWorld().getMaxHeight();
+        }
     }
 
+    /**
+     * Calculates the average height difference of the surrounding blocks from a given location, within a specified distance.
+     *
+     * @param location the location to calculate the average height difference from
+     * @param height   the reference height of the nearest non-empty block
+     * @param distance the distance at which to calculate the average height difference
+     * @return the average height difference of the surrounding blocks within the specified distance
+     */
     public static double getAverageHeightDiffFracture(@NotNull Location location, int height, int distance) {
         double totalHeight = 0;
-        totalHeight += Math.abs(getHeight(location.clone().add(distance, 0, -distance))) - height;
-        totalHeight += Math.abs(getHeight(location.clone().add(distance, 0, distance))) - height;
-        totalHeight += Math.abs(getHeight(location.clone().add(-distance, 0, distance))) - height;
-        totalHeight += Math.abs(getHeight(location.clone().add(-distance, 0, -distance))) - height;
-        totalHeight += Math.abs(getHeight(location.clone().add(0, 0, -distance))) - height;
-        totalHeight += Math.abs(getHeight(location.clone().add(0, 0, distance))) - height;
-        totalHeight += Math.abs(getHeight(location.clone().add(-distance, 0, 0))) - height;
-        totalHeight += Math.abs(getHeight(location.clone().add(distance, 0, 0))) - height;
+        totalHeight += Math.abs(getNearestNonEmptyBlock(location.clone().add(distance, 0, -distance))) - height;
+        totalHeight += Math.abs(getNearestNonEmptyBlock(location.clone().add(distance, 0, distance))) - height;
+        totalHeight += Math.abs(getNearestNonEmptyBlock(location.clone().add(-distance, 0, distance))) - height;
+        totalHeight += Math.abs(getNearestNonEmptyBlock(location.clone().add(-distance, 0, -distance))) - height;
+        totalHeight += Math.abs(getNearestNonEmptyBlock(location.clone().add(0, 0, -distance))) - height;
+        totalHeight += Math.abs(getNearestNonEmptyBlock(location.clone().add(0, 0, distance))) - height;
+        totalHeight += Math.abs(getNearestNonEmptyBlock(location.clone().add(-distance, 0, 0))) - height;
+        totalHeight += Math.abs(getNearestNonEmptyBlock(location.clone().add(distance, 0, 0))) - height;
         return (totalHeight / 8d) / distance;
     }
 
+    /**
+     * Calculates the average height difference angle of the surrounding blocks from a given location within a specified distance.
+     *
+     * @param location the location to calculate the average height difference angle from
+     * @param distance the distance at which to calculate the average height difference angle
+     * @return the average height difference angle of the surrounding blocks within the specified distance
+     */
     public static double getAverageHeightDiffAngle(@NotNull Location location, int distance) {
         double maxHeightDiff = 0;
         double maxHeightDiff2 = 0;
-        double diff = Math.abs(getHeight(location.clone().add(distance, 0, -distance)) - getHeight(location.clone()
-                .add(-distance, 0, distance)));
+        double diff = Math.abs(getNearestNonEmptyBlock(location.clone().add(distance, 0, -distance))
+                - getNearestNonEmptyBlock(location.clone().add(-distance, 0, distance)));
         if (diff >= maxHeightDiff) {
             maxHeightDiff = diff;
             maxHeightDiff2 = maxHeightDiff;
         }
-        diff = Math.abs(getHeight(location.clone().add(distance, 0, distance)) - getHeight(location.clone()
-                .add(-distance, 0, -distance)));
+        diff = Math.abs(getNearestNonEmptyBlock(location.clone().add(distance, 0, distance))
+                - getNearestNonEmptyBlock(location.clone().add(-distance, 0, -distance)));
         if (diff > maxHeightDiff) {
             maxHeightDiff = diff;
             maxHeightDiff2 = maxHeightDiff;
         }
-        diff = Math.abs(getHeight(location.clone().add(distance, 0, 0)) - getHeight(location.clone()
-                .add(-distance, 0, 0)));
+        diff = Math.abs(getNearestNonEmptyBlock(location.clone().add(distance, 0, 0))
+                - getNearestNonEmptyBlock(location.clone().add(-distance, 0, 0)));
         if (diff > maxHeightDiff) {
             maxHeightDiff = diff;
             maxHeightDiff2 = maxHeightDiff;
         }
-        diff = Math.abs(getHeight(location.clone().add(0, 0, -distance)) - getHeight(location.clone()
-                .add(0, 0, distance)));
+        diff = Math.abs(getNearestNonEmptyBlock(location.clone().add(0, 0, -distance))
+                - getNearestNonEmptyBlock(location.clone().add(0, 0, distance)));
         if (diff > maxHeightDiff) {
             maxHeightDiff = diff;
             maxHeightDiff2 = maxHeightDiff;