1.0.6

- Better handling of mushrooms (blocks and plants), delete your plant_mappings config file to get new entries.
- Add SMOOTHING_PRIORITY setting (UP = always keep higher layer value, DOWN = smooth layers near edge, DOWN is new default value)
- Remove old diagonal code

Author: Arona74

README.md

@@ -33,14 +33,15 @@ Remove layers in the specified chunk radius (default: 3, max: 32). Automatically
 
 ### Configuration
 ```
-/layerConfig show                        # Display current configuration
+/layerConfig show                           # Display current configuration
 /layerConfig mode <basic|extended|extreme>  # Set generation mode
-/layerConfig distance <blocks>           # Set max layer distance (3-25)
-/layerConfig edgeThreshold <blocks>      # Set edge height threshold (1-5)
-/layerConfig smoothingCycles <cycles>    # Set smoothing cycles (0-20)
-/layerConfig roundingMode <up|down|nearest>  # Set rounding mode
-/layerConfig preset <basic|extended|extreme>  # Apply preset configuration
-/layerConfig reload                      # Reload config from file
+/layerConfig distance <blocks>              # Set max layer distance (3-25)
+/layerConfig edgeThreshold <blocks>         # Set edge height threshold (1-5)
+/layerConfig smoothingCycles <cycles>       # Set smoothing cycles (0-20)
+/layerConfig roundingMode <up|down|nearest> # Set rounding mode
+/layerConfig smoothingPriority <up|down>    # Set smoothing priority
+/layerConfig preset <basic|extended|extreme> # Apply preset configuration
+/layerConfig reload                         # Reload config from file
 ```
 
 ### Presets
@@ -66,6 +67,7 @@ Configuration files are automatically created in `config/crlayers/` on first run
 - `edge_height_threshold`: Minimum height difference to detect edges
 - `smoothing_cycles`: Number of smoothing passes
 - `smoothing_rounding_mode`: Rounding method (UP, DOWN, NEAREST)
+- `smoothing_priority`: UP (preserve gradients) or DOWN (smooth near edges)
 
 **block_mappings.json**: Vanilla to Conquest Reforged block mappings
 ```json

gradle.properties

@@ -3,7 +3,7 @@ org.gradle.jvmargs=-Xmx2G
 org.gradle.parallel=true
 
 # Mod Properties
-mod_version=1.0.5
+mod_version=1.0.6
 maven_group=io.arona74
 archives_base_name=crlayers
 

src/main/java/io/arona74/crlayers/LayerConfig.java

@@ -73,6 +73,18 @@ public enum RoundingMode {
         NEAREST  // Round to nearest integer
     }
 
+    /**
+     * Smoothing priority mode
+     * UP: Only apply smoothing if it increases the value (preserves extended/extreme gradients)
+     * DOWN: Same as UP except near edge where it will use smoothed value even if it go down from existing value (traditional smoothing)
+     */
+    public static SmoothingPriority SMOOTHING_PRIORITY = SmoothingPriority.DOWN;
+
+    public enum SmoothingPriority {
+        UP,   // Always preserve higher gradient values (only smooth if it increases value)
+        DOWN  // Traditional smoothing near edges and always up everywhere else
+    }
+
     static {
         loadConfig();
     }
@@ -152,6 +164,15 @@ private static void parseConfig(Reader reader) {
                 CRLayers.LOGGER.warn("Invalid rounding mode in config, using default");
             }
         }
+
+        if (config.has("smoothing_priority")) {
+            try {
+                SMOOTHING_PRIORITY = SmoothingPriority.valueOf(
+                    config.get("smoothing_priority").getAsString().toUpperCase());
+            } catch (IllegalArgumentException e) {
+                CRLayers.LOGGER.warn("Invalid smoothing priority in config, using default");
+            }
+        }
     }
 
     private static void createExternalConfig() {
@@ -204,6 +225,8 @@ public static void save() {
             config.addProperty("smoothing_cycles", SMOOTHING_CYCLES);
             config.addProperty("_comment_smoothing_rounding_mode", "How to round averages during smoothing: UP (aggressive), DOWN (conservative), NEAREST (balanced)");
             config.addProperty("smoothing_rounding_mode", SMOOTHING_ROUNDING_MODE.name());
+            config.addProperty("_comment_smoothing_priority", "Smoothing priority: UP (preserve higher gradient values), DOWN (traditional smoothing near edges)");
+            config.addProperty("smoothing_priority", SMOOTHING_PRIORITY.name());
 
             try (Writer writer = Files.newBufferedWriter(configPath)) {
                 GSON.newBuilder().setPrettyPrinting().create().toJson(config, writer);

src/main/java/io/arona74/crlayers/LayerGenerator.java

@@ -501,6 +501,7 @@ private void smoothingPass(int currentY,
             int sum = 0;
             int count = 0;
             int maxCardinalNeighborValue = 0;
+            boolean hasEBlockNeighbor = false;
 
             // Only consider the 4 cardinal neighbors
             for (int[] offset : cardinalOffsets) {
@@ -513,6 +514,7 @@ private void smoothingPass(int currentY,
                 } else if (eBlocks.contains(neighbor)) {
                     sum += 0;
                     count++;
+                    hasEBlockNeighbor = true;
                 } else if (layerValues.containsKey(neighbor)) {
                     int neighborValue = layerValues.get(neighbor);
                     sum += neighborValue;
@@ -546,9 +548,23 @@ private void smoothingPass(int currentY,
                     if (value < 1) value = 1; // safety clamp
                 }
 
-                // IMPORTANT: Only apply smoothing if it INCREASES the value (preserves extended gradients)
-                if (existingValue == null || value > existingValue) {
-                    newValues.put(lBlock, value);
+                // Apply smoothing based on priority mode
+                if (LayerConfig.SMOOTHING_PRIORITY == LayerConfig.SmoothingPriority.UP) {
+                    // UP: Only apply smoothing if it INCREASES the value (preserves extended gradients)
+                    if (existingValue == null || value > existingValue) {
+                        newValues.put(lBlock, value);
+                    }
+                } else {
+                    // DOWN: Hybrid approach
+                    if (hasEBlockNeighbor) {
+                        // Near edges: Traditional smoothing (always apply)
+                        newValues.put(lBlock, value);
+                    } else {
+                        // Away from edges: Preserve gradients (only apply if higher, like UP mode)
+                        if (existingValue == null || value > existingValue) {
+                            newValues.put(lBlock, value);
+                        }
+                    }
                 }
             }
         }
@@ -567,16 +583,12 @@ private void spreadLayersFromHBlocks(int currentY,
                                         Map<BlockPos, Integer> layerValues,
                                         int maxDistance) {
 
-        // 8 directions: N, NE, E, SE, S, SW, W, NW
+        // 4 directions: N, E, S, W
         int[][] directions = {
             {0, -1},  // N
-            {1, -1},  // NE (diagonal)
             {1, 0},   // E
-            {1, 1},   // SE (diagonal)
             {0, 1},   // S
-            {-1, 1},  // SW (diagonal)
             {-1, 0},  // W
-            {-1, -1}  // NW (diagonal)
         };
 
         // Track path length statistics
@@ -587,7 +599,6 @@ private void spreadLayersFromHBlocks(int currentY,
         for (BlockPos hBlock : hBlocks) {
             for (int dirIdx = 0; dirIdx < directions.length; dirIdx++) {
                 int[] dir = directions[dirIdx];
-                boolean isDiagonal = (dir[0] != 0 && dir[1] != 0);
 
                 // Walk in this direction and collect L blocks
                 List<BlockPos> pathLBlocks = new ArrayList<>();
@@ -619,7 +630,7 @@ private void spreadLayersFromHBlocks(int currentY,
                     int pathLength = pathLBlocks.size();
                     pathLengthCounts.put(pathLength, pathLengthCounts.getOrDefault(pathLength, 0) + 1);
                     pathsWithLayers++;
-                    applyGradient(pathLBlocks, isDiagonal, layerValues);
+                    applyGradient(pathLBlocks, layerValues);
                 }
             }
         }
@@ -645,9 +656,9 @@ private String formatPathStats(Map<Integer, Integer> pathLengthCounts) {
     /**
      * Apply gradient to a path of L blocks
      */
-    private void applyGradient(List<BlockPos> path, boolean isDiagonal, Map<BlockPos, Integer> layerValues) {
+    private void applyGradient(List<BlockPos> path, Map<BlockPos, Integer> layerValues) {
         int availableBlocks = path.size();
-        int[] gradient = getGradientForSpace(availableBlocks, isDiagonal);
+        int[] gradient = getGradient(availableBlocks);
 
         for (int i = 0; i < path.size() && i < gradient.length; i++) {
             BlockPos pos = path.get(i);
@@ -661,28 +672,23 @@ private void applyGradient(List<BlockPos> path, boolean isDiagonal, Map<BlockPos
         }
     }
 
-    /**
-     * Get gradient array for given available space
-     */
-    private int[] getGradientForSpace(int space, boolean isDiagonal) {
-        if (isDiagonal) {
-            return getDiagonalGradient(space);
-        } else {
-            return getNormalGradient(space);
-        }
-    }
-
-    private int[] getNormalGradient(int space) {
+    private int[] getGradient(int space) {
         // EXTREME mode: use extreme gradients with triple repeated values
         if (LayerConfig.MODE == LayerConfig.GenerationMode.EXTREME) {
             return getExtremeNormalGradient(space);
         }
-
         // EXTENDED mode: use extended gradients with repeated values
         if (LayerConfig.MODE == LayerConfig.GenerationMode.EXTENDED) {
             return getExtendedNormalGradient(space);
         }
+        // BASIC mode: linear gradients
+        if (LayerConfig.MODE == LayerConfig.GenerationMode.BASIC) {
+            return getNormalGradient(space);
+        }
+        return new int[0];
+    }
 
+    private int[] getNormalGradient(int space) {
         // BASIC mode: linear gradients
         if (space >= 7) {
             return new int[]{7, 6, 5, 4, 3, 2, 1};
@@ -724,22 +730,9 @@ private int[] getExtendedNormalGradient(int space) {
             return new int[]{7, 6, 5, 4, 4, 3, 2, 1};
         }
         // For space <= 7, fall back to basic gradients
-        else if (space >= 7) {
-            return new int[]{7, 6, 5, 4, 3, 2, 1};
-        } else if (space >= 6) {
-            return new int[]{7, 6, 5, 3, 2, 1};
-        } else if (space >= 5) {
-            return new int[]{6, 5, 4, 2, 1};
-        } else if (space >= 4) {
-            return new int[]{7, 5, 3, 1};
-        } else if (space >= 3) {
-            return new int[]{6, 4, 2};
-        } else if (space >= 2) {
-            return new int[]{5, 2};
-        } else if (space >= 1) {
-            return new int[]{4};
+        else {
+            return getNormalGradient(space);
         }
-        return new int[0];
     }
 
     /**
@@ -768,12 +761,6 @@ private int[] getExtremeNormalGradient(int space) {
             return getExtendedNormalGradient(space);
         }
     }
-
-    private int[] getDiagonalGradient(int space) {
-        // Diagonal gradients are currently disabled (return empty array)
-        // You can enable them if needed for more coverage
-        return new int[0];
-    }
 
     /**
      * Place all layer blocks
@@ -1027,7 +1014,15 @@ private BlockPos findSurfaceBlock(BlockPos pos) {
                 surfacePos = surfacePos.down();
                 continue;
             }
-            
+
+            // Skip mushroom blocks (big mushroom structures)
+            if (block == Blocks.BROWN_MUSHROOM_BLOCK ||
+                block == Blocks.RED_MUSHROOM_BLOCK ||
+                block == Blocks.MUSHROOM_STEM) {
+                surfacePos = surfacePos.down();
+                continue;
+            }
+
             // Skip plants and flowers
             if (block.getDefaultState().isIn(net.minecraft.registry.tag.BlockTags.FLOWERS) ||
                 block.getDefaultState().isIn(net.minecraft.registry.tag.BlockTags.SAPLINGS) ||

src/main/java/io/arona74/crlayers/LayerGeneratorCommand.java

@@ -68,6 +68,15 @@ public static void register(CommandDispatcher<ServerCommandSource> dispatcher) {
                     })
                     .executes(LayerGeneratorCommand::setRoundingMode)))
 
+            .then(CommandManager.literal("smoothingPriority")
+                .then(CommandManager.argument("priority", StringArgumentType.word())
+                    .suggests((context, builder) -> {
+                        builder.suggest("up");
+                        builder.suggest("down");
+                        return builder.buildFuture();
+                    })
+                    .executes(LayerGeneratorCommand::setSmoothingPriority)))
+
             .then(CommandManager.literal("reload")
                 .executes(LayerGeneratorCommand::reloadConfig))
 
@@ -209,7 +218,9 @@ private static int showConfig(CommandContext<ServerCommandSource> context) {
             "§eSmoothing Cycles: §f%d", LayerConfig.SMOOTHING_CYCLES)), false);
         source.sendFeedback(() -> Text.literal(String.format(
             "§eRounding Mode: §f%s", LayerConfig.SMOOTHING_ROUNDING_MODE.name())), false);
-        
+        source.sendFeedback(() -> Text.literal(String.format(
+            "§eSmoothing Priority: §f%s", LayerConfig.SMOOTHING_PRIORITY.name())), false);
+
         String modeDesc = switch (LayerConfig.MODE) {
             case BASIC -> "§7Linear gradient up to 7: 7→6→5→4→3→2→1";
             case EXTENDED -> "§7Gradual steps up to 14: 7,7→6,6→5,5→4,4→3,3→2,2→1,1";
@@ -304,6 +315,29 @@ private static int setRoundingMode(CommandContext<ServerCommandSource> context)
         return 1;
     }
 
+    private static int setSmoothingPriority(CommandContext<ServerCommandSource> context) {
+        ServerCommandSource source = context.getSource();
+        String priorityName = StringArgumentType.getString(context, "priority").toLowerCase();
+
+        LayerConfig.SmoothingPriority priority = switch (priorityName) {
+            case "up" -> LayerConfig.SmoothingPriority.UP;
+            case "down" -> LayerConfig.SmoothingPriority.DOWN;
+            default -> {
+                source.sendError(Text.literal("§cUnknown smoothing priority. Use: up or down"));
+                yield null;
+            }
+        };
+
+        if (priority == null) return 0;
+
+        LayerConfig.SMOOTHING_PRIORITY = priority;
+        LayerConfig.save();
+        source.sendFeedback(() -> Text.literal(
+            String.format("§aSet smoothing priority to: §f%s", priority.name())), true);
+
+        return 1;
+    }
+
     private static int reloadConfig(CommandContext<ServerCommandSource> context) {
         ServerCommandSource source = context.getSource();
 
@@ -333,20 +367,23 @@ private static int applyPreset(CommandContext<ServerCommandSource> context) {
                     LayerConfig.EDGE_HEIGHT_THRESHOLD = 1;
                     LayerConfig.SMOOTHING_CYCLES = 6;
                     LayerConfig.SMOOTHING_ROUNDING_MODE = LayerConfig.RoundingMode.DOWN;
+                    LayerConfig.SMOOTHING_PRIORITY = LayerConfig.SmoothingPriority.DOWN;
                 }
                 case "extended" -> {
                     LayerConfig.MODE = LayerConfig.GenerationMode.EXTENDED;
                     LayerConfig.MAX_LAYER_DISTANCE = 14;
                     LayerConfig.EDGE_HEIGHT_THRESHOLD = 1;
                     LayerConfig.SMOOTHING_CYCLES = 13;
                     LayerConfig.SMOOTHING_ROUNDING_MODE = LayerConfig.RoundingMode.DOWN;
+                    LayerConfig.SMOOTHING_PRIORITY = LayerConfig.SmoothingPriority.DOWN;
                 }
                 case "extreme" -> {
                     LayerConfig.MODE = LayerConfig.GenerationMode.EXTREME;
                     LayerConfig.MAX_LAYER_DISTANCE = 21;
                     LayerConfig.EDGE_HEIGHT_THRESHOLD = 1;
                     LayerConfig.SMOOTHING_CYCLES = 20;
                     LayerConfig.SMOOTHING_ROUNDING_MODE = LayerConfig.RoundingMode.DOWN;
+                    LayerConfig.SMOOTHING_PRIORITY = LayerConfig.SmoothingPriority.DOWN;
                 }
                 default -> {
                     source.sendError(Text.literal("§cUnknown preset. Use: basic, extended, or extreme"));

src/main/resources/layer_config.json

@@ -9,5 +9,7 @@
   "_comment_smoothing_cycles": "Number of smoothing passes after layer spreading. More cycles = smoother transitions. Recommended: 4-8",
   "smoothing_cycles": 6,
   "_comment_smoothing_rounding_mode": "How to round averages during smoothing: UP (aggressive), DOWN (conservative), NEAREST (balanced)",
-  "smoothing_rounding_mode": "NEAREST"
+  "smoothing_rounding_mode": "DOWN",
+  "_comment_smoothing_priority": "Smoothing priority: UP (preserve higher gradient values), DOWN (traditional smoothing near edges)",
+  "smoothing_priority": "DOWN"
 }

src/main/resources/plant_mappings.json

@@ -21,6 +21,8 @@
     "minecraft:sunflower": "conquest:sunflower",
     "minecraft:lilac": "conquest:lilac",
     "minecraft:rose_bush": "conquest:rose_bush",
-    "minecraft:peony": "conquest:peony"
+    "minecraft:peony": "conquest:peony",
+    "minecraft:brown_mushroom": "conquest:brown_mushroom",
+    "minecraft:red_mushroom": "conquest:red_mushroom"
   }
 }