Address code review feedback

src/data_processing.rs

@@ -69,17 +69,19 @@ pub fn generate_world_with_options(
 
     println!("{} Processing data...", "[4/7]".bold());
 
-    // Build highway connectivity map once before processing
-    let highway_connectivity = highways::build_highway_connectivity_map(&elements);
-
     // Set ground reference in the editor to enable elevation-aware block placement
     editor.set_ground(Arc::clone(&ground));
 
     println!("{} Processing terrain...", "[5/7]".bold());
     emit_gui_progress_update(25.0, "Processing terrain...");
 
-    // Pre-compute all flood fills in parallel for better CPU utilization
-    let mut flood_fill_cache = FloodFillCache::precompute(&elements, args.timeout.as_ref());
+    // Run both precomputations concurrently using rayon::join
+    // This overlaps highway connectivity map building with flood fill computation
+    let timeout_ref = args.timeout.as_ref();
+    let (highway_connectivity, mut flood_fill_cache) = rayon::join(
+        || highways::build_highway_connectivity_map(&elements),
+        || FloodFillCache::precompute(&elements, timeout_ref),
+    );
     println!("Pre-computed {} flood fills", flood_fill_cache.way_count());
 
     // Process data
@@ -262,8 +264,7 @@ pub fn generate_world_with_options(
     let total_iterations_grnd: f64 = total_blocks as f64;
     let progress_increment_grnd: f64 = 20.0 / total_iterations_grnd;
 
-    // Check if terrain elevation is enabled; when disabled, we can skip ground level lookups entirely
-    let terrain_enabled = ground.elevation_enabled;
+    let groundlayer_block = GRASS_BLOCK;
 
     // Process ground generation chunk-by-chunk for better cache locality.
     // This keeps the same region/chunk HashMap entries hot in CPU cache,
@@ -283,19 +284,11 @@ pub fn generate_world_with_options(
 
             for x in chunk_min_x..=chunk_max_x {
                 for z in chunk_min_z..=chunk_max_z {
-                    // Get ground level, when terrain is enabled, look it up once per block
-                    // When disabled, use constant ground_level (no function call overhead)
-                    let ground_y = if terrain_enabled {
-                        editor.get_ground_level(x, z)
-                    } else {
-                        args.ground_level
-                    };
-
                     // Add default dirt and grass layer if there isn't a stone layer already
-                    if !editor.check_for_block_absolute(x, ground_y, z, Some(&[STONE]), None) {
-                        editor.set_block_absolute(GRASS_BLOCK, x, ground_y, z, None, None);
-                        editor.set_block_absolute(DIRT, x, ground_y - 1, z, None, None);
-                        editor.set_block_absolute(DIRT, x, ground_y - 2, z, None, None);
+                    if !editor.check_for_block(x, 0, z, Some(&[STONE])) {
+                        editor.set_block(groundlayer_block, x, 0, z, None, None);
+                        editor.set_block(DIRT, x, -1, z, None, None);
+                        editor.set_block(DIRT, x, -2, z, None, None);
                     }
 
                     // Fill underground with stone
@@ -307,7 +300,7 @@ pub fn generate_world_with_options(
                             MIN_Y + 1,
                             z,
                             x,
-                            ground_y - 3,
+                            editor.get_absolute_y(x, -3, z),
                             z,
                             None,
                             None,

src/element_processing/bridges.rs

@@ -3,97 +3,37 @@ use crate::bresenham::bresenham_line;
 use crate::osm_parser::ProcessedWay;
 use crate::world_editor::WorldEditor;
 
-// TODO FIX - This handles ways with bridge=yes tag (e.g., highway bridges)
+// TODO FIX
 #[allow(dead_code)]
 pub fn generate_bridges(editor: &mut WorldEditor, element: &ProcessedWay) {
     if let Some(_bridge_type) = element.tags.get("bridge") {
-        let bridge_height = 3; // Height above the ground level
-
-        // Get start and end node elevations and use MAX for level bridge deck
-        // Using MAX ensures bridges don't dip when multiple bridge ways meet in a valley
-        let bridge_deck_ground_y = if element.nodes.len() >= 2 {
-            let start_node = &element.nodes[0];
-            let end_node = &element.nodes[element.nodes.len() - 1];
-            let start_y = editor.get_ground_level(start_node.x, start_node.z);
-            let end_y = editor.get_ground_level(end_node.x, end_node.z);
-            start_y.max(end_y)
-        } else {
-            return; // Need at least 2 nodes for a bridge
-        };
-
-        // Calculate total bridge length for ramp positioning
-        let total_length: f64 = element
-            .nodes
-            .windows(2)
-            .map(|pair| {
-                let dx = (pair[1].x - pair[0].x) as f64;
-                let dz = (pair[1].z - pair[0].z) as f64;
-                (dx * dx + dz * dz).sqrt()
-            })
-            .sum();
-
-        if total_length == 0.0 {
-            return;
-        }
-
-        let mut accumulated_length: f64 = 0.0;
+        let bridge_height = 3; // Fixed height
 
         for i in 1..element.nodes.len() {
             let prev = &element.nodes[i - 1];
             let cur = &element.nodes[i];
-
-            let segment_dx = (cur.x - prev.x) as f64;
-            let segment_dz = (cur.z - prev.z) as f64;
-            let segment_length = (segment_dx * segment_dx + segment_dz * segment_dz).sqrt();
-
             let points = bresenham_line(prev.x, 0, prev.z, cur.x, 0, cur.z);
 
-            let ramp_length = (total_length * 0.15).clamp(6.0, 20.0) as usize; // 15% of bridge, min 6, max 20 blocks
+            let total_length = points.len();
+            let ramp_length = 6; // Length of ramp at each end
 
             for (idx, (x, _, z)) in points.iter().enumerate() {
-                // Calculate progress along this segment
-                let segment_progress = if points.len() > 1 {
-                    idx as f64 / (points.len() - 1) as f64
-                } else {
-                    0.0
-                };
-
-                // Calculate overall progress along the entire bridge
-                let point_distance = accumulated_length + segment_progress * segment_length;
-                let overall_progress = (point_distance / total_length).clamp(0.0, 1.0);
-                let total_len_usize = total_length as usize;
-                let overall_idx = (overall_progress * total_len_usize as f64) as usize;
-
-                // Calculate ramp height offset
-                let ramp_offset = if overall_idx < ramp_length {
+                let height = if idx < ramp_length {
                     // Start ramp (rising)
-                    (overall_idx as f64 * bridge_height as f64 / ramp_length as f64) as i32
-                } else if overall_idx >= total_len_usize.saturating_sub(ramp_length) {
+                    (idx * bridge_height) / ramp_length
+                } else if idx >= total_length - ramp_length {
                     // End ramp (descending)
-                    let dist_from_end = total_len_usize - overall_idx;
-                    (dist_from_end as f64 * bridge_height as f64 / ramp_length as f64) as i32
+                    ((total_length - idx) * bridge_height) / ramp_length
                 } else {
                     // Middle section (constant height)
                     bridge_height
                 };
 
-                // Use fixed bridge deck height (max of endpoints) plus ramp offset
-                let bridge_y = bridge_deck_ground_y + ramp_offset;
-
                 // Place bridge blocks
                 for dx in -2..=2 {
-                    editor.set_block_absolute(
-                        LIGHT_GRAY_CONCRETE,
-                        *x + dx,
-                        bridge_y,
-                        *z,
-                        None,
-                        None,
-                    );
+                    editor.set_block(LIGHT_GRAY_CONCRETE, *x + dx, height as i32, *z, None, None);
                 }
             }
-
-            accumulated_length += segment_length;
         }
     }
 }

src/element_processing/buildings.rs

@@ -1525,8 +1525,6 @@ pub fn generate_building_from_relation(
 }
 
 /// Generates a bridge structure, paying attention to the "level" tag.
-/// Bridge deck is interpolated between start and end point elevations to avoid
-/// being dragged down by valleys underneath.
 fn generate_bridge(
     editor: &mut WorldEditor,
     element: &ProcessedWay,
@@ -1536,7 +1534,7 @@ fn generate_bridge(
     let floor_block: Block = STONE;
     let railing_block: Block = STONE_BRICKS;
 
-    // Calculate bridge level offset based on the "level" tag
+    // Calculate bridge level based on the "level" tag (computed once, used throughout)
     let bridge_y_offset = if let Some(level_str) = element.tags.get("level") {
         if let Ok(level) = level_str.parse::<i32>() {
             (level * 3) + 1
@@ -1547,37 +1545,21 @@ fn generate_bridge(
         1 // Default elevation
     };
 
-    // Need at least 2 nodes to form a bridge
-    if element.nodes.len() < 2 {
-        return;
-    }
-
-    // Get start and end node elevations and use MAX for level bridge deck
-    // Using MAX ensures bridges don't dip when multiple bridge ways meet in a valley
-    let start_node = &element.nodes[0];
-    let end_node = &element.nodes[element.nodes.len() - 1];
-    let start_y = editor.get_ground_level(start_node.x, start_node.z);
-    let end_y = editor.get_ground_level(end_node.x, end_node.z);
-    let bridge_deck_ground_y = start_y.max(end_y);
-
     // Process the nodes to create bridge pathways and railings
     let mut previous_node: Option<(i32, i32)> = None;
-
     for node in &element.nodes {
         let x: i32 = node.x;
         let z: i32 = node.z;
 
         // Create bridge path using Bresenham's line
         if let Some(prev) = previous_node {
-            let bridge_points: Vec<(i32, i32, i32)> = bresenham_line(prev.0, 0, prev.1, x, 0, z);
-
-            for (bx, _, bz) in bridge_points.iter() {
-                // Use fixed bridge deck height (max of endpoints)
-                let bridge_y = bridge_deck_ground_y + bridge_y_offset;
+            let bridge_points: Vec<(i32, i32, i32)> =
+                bresenham_line(prev.0, bridge_y_offset, prev.1, x, bridge_y_offset, z);
 
+            for (bx, by, bz) in bridge_points {
                 // Place railing blocks
-                editor.set_block_absolute(railing_block, *bx, bridge_y + 1, *bz, None, None);
-                editor.set_block_absolute(railing_block, *bx, bridge_y, *bz, None, None);
+                editor.set_block(railing_block, bx, by + 1, bz, None, None);
+                editor.set_block(railing_block, bx, by, bz, None, None);
             }
         }
 
@@ -1587,11 +1569,8 @@ fn generate_bridge(
     // Flood fill the area between the bridge path nodes (uses cache)
     let bridge_area: Vec<(i32, i32)> = flood_fill_cache.get_or_compute(element, floodfill_timeout);
 
-    // Use the same level bridge deck height for filled areas
-    let floor_y = bridge_deck_ground_y + bridge_y_offset;
-
     // Place floor blocks
     for (x, z) in bridge_area {
-        editor.set_block_absolute(floor_block, x, floor_y, z, None, None);
+        editor.set_block(floor_block, x, bridge_y_offset, z, None, None);
     }
 }

src/element_processing/highways.rs

@@ -5,14 +5,12 @@ use crate::coordinate_system::cartesian::XZPoint;
 use crate::floodfill_cache::FloodFillCache;
 use crate::osm_parser::{ProcessedElement, ProcessedWay};
 use crate::world_editor::WorldEditor;
+use rayon::prelude::*;
 use std::collections::HashMap;
 
 /// Type alias for highway connectivity map
 pub type HighwayConnectivityMap = HashMap<(i32, i32), Vec<i32>>;
 
-/// Minimum terrain dip (in blocks) below max endpoint elevation to classify a bridge as valley-spanning
-const VALLEY_BRIDGE_THRESHOLD: i32 = 7;
-
 /// Generates highways with elevation support based on layer tags and connectivity analysis
 pub fn generate_highways(
     editor: &mut WorldEditor,
@@ -31,39 +29,41 @@ pub fn generate_highways(
 }
 
 /// Build a connectivity map for highway endpoints to determine where slopes are needed.
+/// Uses parallel processing for better performance on large element sets.
 pub fn build_highway_connectivity_map(elements: &[ProcessedElement]) -> HighwayConnectivityMap {
-    let mut connectivity_map: HashMap<(i32, i32), Vec<i32>> = HashMap::new();
+    // Parallel map phase: extract connectivity data from each highway element
+    let partial_maps: Vec<Vec<((i32, i32), i32)>> = elements
+        .par_iter()
+        .filter_map(|element| {
+            if let ProcessedElement::Way(way) = element {
+                if way.tags.contains_key("highway") && !way.nodes.is_empty() {
+                    let layer_value = way
+                        .tags
+                        .get("layer")
+                        .and_then(|layer| layer.parse::<i32>().ok())
+                        .unwrap_or(0);
 
-    for element in elements {
-        if let ProcessedElement::Way(way) = element {
-            if way.tags.contains_key("highway") {
-                let layer_value = way
-                    .tags
-                    .get("layer")
-                    .and_then(|layer| layer.parse::<i32>().ok())
-                    .unwrap_or(0);
+                    // Treat negative layers as ground level (0) for connectivity
+                    let layer_value = if layer_value < 0 { 0 } else { layer_value };
 
-                // Treat negative layers as ground level (0) for connectivity
-                let layer_value = if layer_value < 0 { 0 } else { layer_value };
-
-                // Add connectivity for start and end nodes
-                if !way.nodes.is_empty() {
                     let start_node = &way.nodes[0];
                     let end_node = &way.nodes[way.nodes.len() - 1];
 
                     let start_coord = (start_node.x, start_node.z);
                     let end_coord = (end_node.x, end_node.z);
 
-                    connectivity_map
-                        .entry(start_coord)
-                        .or_default()
-                        .push(layer_value);
-                    connectivity_map
-                        .entry(end_coord)
-                        .or_default()
-                        .push(layer_value);
+                    return Some(vec![(start_coord, layer_value), (end_coord, layer_value)]);
                 }
             }
+            None
+        })
+        .collect();
+
+    // Sequential reduce phase: merge all partial results into final map
+    let mut connectivity_map: HashMap<(i32, i32), Vec<i32>> = HashMap::new();
+    for entries in partial_maps {
+        for (coord, layer) in entries {
+            connectivity_map.entry(coord).or_default().push(layer);
         }
     }
 
@@ -163,11 +163,6 @@ fn generate_highways_internal(
             let mut add_outline = false;
             let scale_factor = args.scale;
 
-            // Check if this is a bridge - bridges need special elevation handling
-            // to span across valleys instead of following terrain
-            // Accept any bridge tag value except "no" (e.g., "yes", "viaduct", "aqueduct", etc.)
-            let is_bridge = element.tags().get("bridge").is_some_and(|v| v != "no");
-
             // Parse the layer value for elevation calculation
             let layer_value = element
                 .tags()
@@ -257,7 +252,6 @@ fn generate_highways_internal(
             let base_elevation = layer_value * LAYER_HEIGHT_STEP;
 
             // Check if we need slopes at start and end
-            // This is used for overpasses that need ramps to ground-level roads
             let needs_start_slope =
                 should_add_slope_at_node(&way.nodes[0], layer_value, highway_connectivity);
             let needs_end_slope = should_add_slope_at_node(
@@ -266,67 +260,10 @@ fn generate_highways_internal(
                 highway_connectivity,
             );
 
-            // Calculate total way length for slope distribution (needed before valley bridge check)
+            // Calculate total way length for slope distribution
             let total_way_length = calculate_way_length(way);
 
-            // For bridges: detect if this spans a valley by checking terrain profile
-            // A valley bridge has terrain that dips significantly below the endpoints
-            // Skip valley detection entirely if terrain is disabled (no valleys in flat terrain)
-            // Skip very short bridges (< 25 blocks) as they're unlikely to span significant valleys
-            let terrain_enabled = editor
-                .get_ground()
-                .map(|g| g.elevation_enabled)
-                .unwrap_or(false);
-
-            let (is_valley_bridge, bridge_deck_y) =
-                if is_bridge && terrain_enabled && way.nodes.len() >= 2 && total_way_length >= 25 {
-                    let start_node = &way.nodes[0];
-                    let end_node = &way.nodes[way.nodes.len() - 1];
-                    let start_y = editor.get_ground_level(start_node.x, start_node.z);
-                    let end_y = editor.get_ground_level(end_node.x, end_node.z);
-                    let max_endpoint_y = start_y.max(end_y);
-
-                    // Sample terrain at middle nodes only (excluding endpoints we already have)
-                    // This avoids redundant get_ground_level() calls
-                    let middle_nodes = &way.nodes[1..way.nodes.len().saturating_sub(1)];
-                    let sampled_min = if middle_nodes.is_empty() {
-                        // No middle nodes, just use endpoints
-                        start_y.min(end_y)
-                    } else {
-                        // Sample up to 3 middle points (5 total with endpoints) for performance
-                        // Valleys are wide terrain features, so sparse sampling is sufficient
-                        let sample_count = middle_nodes.len().min(3);
-                        let step = if sample_count > 1 {
-                            (middle_nodes.len() - 1) / (sample_count - 1)
-                        } else {
-                            1
-                        };
-
-                        middle_nodes
-                            .iter()
-                            .step_by(step.max(1))
-                            .map(|node| editor.get_ground_level(node.x, node.z))
-                            .min()
-                            .unwrap_or(max_endpoint_y)
-                    };
-
-                    // Include endpoint elevations in the minimum calculation
-                    let min_terrain_y = sampled_min.min(start_y).min(end_y);
-
-                    // If ANY sampled point along the bridge is significantly lower than the max endpoint,
-                    // treat as valley bridge
-                    let is_valley = min_terrain_y < max_endpoint_y - VALLEY_BRIDGE_THRESHOLD;
-
-                    if is_valley {
-                        (true, max_endpoint_y)
-                    } else {
-                        (false, 0)
-                    }
-                } else {
-                    (false, 0)
-                };
-
-            // Check if this is a short isolated elevated segment (layer > 0), if so, treat as ground level
+            // Check if this is a short isolated elevated segment - if so, treat as ground level
             let is_short_isolated_elevated =
                 needs_start_slope && needs_end_slope && layer_value > 0 && total_way_length <= 35;
 
@@ -363,28 +300,17 @@ fn generate_highways_internal(
                     let gap_length: i32 = (5.0 * scale_factor).ceil() as i32;
 
                     for (point_index, (x, _, z)) in bresenham_points.iter().enumerate() {
-                        // Calculate Y elevation for this point
-                        // For valley bridges: use fixed deck height (max of endpoints) to stay level
-                        // For overpasses and regular roads: use terrain-relative elevation with slopes
-                        let (current_y, use_absolute_y) = if is_valley_bridge {
-                            // Valley bridge deck is level at the maximum endpoint elevation
-                            // Don't add base_elevation - the layer tag indicates it's above water/road,
-                            // not that it should be higher than the terrain endpoints
-                            (bridge_deck_y, true)
-                        } else {
-                            // Regular road or overpass: use terrain-relative calculation with ramps
-                            let y = calculate_point_elevation(
-                                segment_index,
-                                point_index,
-                                segment_length,
-                                total_segments,
-                                effective_elevation,
-                                effective_start_slope,
-                                effective_end_slope,
-                                slope_length,
-                            );
-                            (y, false)
-                        };
+                        // Calculate Y elevation for this point based on slopes and layer
+                        let current_y = calculate_point_elevation(
+                            segment_index,
+                            point_index,
+                            segment_length,
+                            total_segments,
+                            effective_elevation,
+                            effective_start_slope,
+                            effective_end_slope,
+                            slope_length,
+                        );
 
                         // Draw the road surface for the entire width
                         for dx in -block_range..=block_range {
@@ -400,32 +326,12 @@ fn generate_highways_internal(
                                     let is_horizontal: bool = (x2 - x1).abs() >= (z2 - z1).abs();
                                     if is_horizontal {
                                         if set_x % 2 < 1 {
-                                            if use_absolute_y {
-                                                editor.set_block_absolute(
-                                                    WHITE_CONCRETE,
-                                                    set_x,
-                                                    current_y,
-                                                    set_z,
-                                                    Some(&[BLACK_CONCRETE]),
-                                                    None,
-                                                );
-                                            } else {
-                                                editor.set_block(
-                                                    WHITE_CONCRETE,
-                                                    set_x,
-                                                    current_y,
-                                                    set_z,
-                                                    Some(&[BLACK_CONCRETE]),
-                                                    None,
-                                                );
-                                            }
-                                        } else if use_absolute_y {
-                                            editor.set_block_absolute(
-                                                BLACK_CONCRETE,
+                                            editor.set_block(
+                                                WHITE_CONCRETE,
                                                 set_x,
                                                 current_y,
                                                 set_z,
-                                                None,
+                                                Some(&[BLACK_CONCRETE]),
                                                 None,
                                             );
                                         } else {
@@ -439,32 +345,12 @@ fn generate_highways_internal(
                                             );
                                         }
                                     } else if set_z % 2 < 1 {
-                                        if use_absolute_y {
-                                            editor.set_block_absolute(
-                                                WHITE_CONCRETE,
-                                                set_x,
-                                                current_y,
-                                                set_z,
-                                                Some(&[BLACK_CONCRETE]),
-                                                None,
-                                            );
-                                        } else {
-                                            editor.set_block(
-                                                WHITE_CONCRETE,
-                                                set_x,
-                                                current_y,
-                                                set_z,
-                                                Some(&[BLACK_CONCRETE]),
-                                                None,
-                                            );
-                                        }
-                                    } else if use_absolute_y {
-                                        editor.set_block_absolute(
-                                            BLACK_CONCRETE,
+                                        editor.set_block(
+                                            WHITE_CONCRETE,
                                             set_x,
                                             current_y,
                                             set_z,
-                                            None,
+                                            Some(&[BLACK_CONCRETE]),
                                             None,
                                         );
                                     } else {
@@ -477,15 +363,6 @@ fn generate_highways_internal(
                                             None,
                                         );
                                     }
-                                } else if use_absolute_y {
-                                    editor.set_block_absolute(
-                                        block_type,
-                                        set_x,
-                                        current_y,
-                                        set_z,
-                                        None,
-                                        Some(&[BLACK_CONCRETE, WHITE_CONCRETE]),
-                                    );
                                 } else {
                                     editor.set_block(
                                         block_type,
@@ -497,53 +374,30 @@ fn generate_highways_internal(
                                     );
                                 }
 
-                                // Add stone brick foundation underneath elevated highways/bridges for thickness
-                                if (effective_elevation > 0 || use_absolute_y) && current_y > 0 {
+                                // Add stone brick foundation underneath elevated highways for thickness
+                                if effective_elevation > 0 && current_y > 0 {
                                     // Add 1 layer of stone bricks underneath the highway surface
-                                    if use_absolute_y {
-                                        editor.set_block_absolute(
-                                            STONE_BRICKS,
-                                            set_x,
-                                            current_y - 1,
-                                            set_z,
-                                            None,
-                                            None,
-                                        );
-                                    } else {
-                                        editor.set_block(
-                                            STONE_BRICKS,
-                                            set_x,
-                                            current_y - 1,
-                                            set_z,
-                                            None,
-                                            None,
-                                        );
-                                    }
+                                    editor.set_block(
+                                        STONE_BRICKS,
+                                        set_x,
+                                        current_y - 1,
+                                        set_z,
+                                        None,
+                                        None,
+                                    );
                                 }
 
-                                // Add support pillars for elevated highways/bridges
-                                if (effective_elevation != 0 || use_absolute_y) && current_y > 0 {
-                                    if use_absolute_y {
-                                        add_highway_support_pillar_absolute(
-                                            editor,
-                                            set_x,
-                                            current_y,
-                                            set_z,
-                                            dx,
-                                            dz,
-                                            block_range,
-                                        );
-                                    } else {
-                                        add_highway_support_pillar(
-                                            editor,
-                                            set_x,
-                                            current_y,
-                                            set_z,
-                                            dx,
-                                            dz,
-                                            block_range,
-                                        );
-                                    }
+                                // Add support pillars for elevated highways
+                                if effective_elevation != 0 && current_y > 0 {
+                                    add_highway_support_pillar(
+                                        editor,
+                                        set_x,
+                                        current_y,
+                                        set_z,
+                                        dx,
+                                        dz,
+                                        block_range,
+                                    );
                                 }
                             }
                         }
@@ -554,49 +408,27 @@ fn generate_highways_internal(
                             for dz in -block_range..=block_range {
                                 let outline_x = x - block_range - 1;
                                 let outline_z = z + dz;
-                                if use_absolute_y {
-                                    editor.set_block_absolute(
-                                        LIGHT_GRAY_CONCRETE,
-                                        outline_x,
-                                        current_y,
-                                        outline_z,
-                                        None,
-                                        None,
-                                    );
-                                } else {
-                                    editor.set_block(
-                                        LIGHT_GRAY_CONCRETE,
-                                        outline_x,
-                                        current_y,
-                                        outline_z,
-                                        None,
-                                        None,
-                                    );
-                                }
+                                editor.set_block(
+                                    LIGHT_GRAY_CONCRETE,
+                                    outline_x,
+                                    current_y,
+                                    outline_z,
+                                    None,
+                                    None,
+                                );
                             }
                             // Right outline
                             for dz in -block_range..=block_range {
                                 let outline_x = x + block_range + 1;
                                 let outline_z = z + dz;
-                                if use_absolute_y {
-                                    editor.set_block_absolute(
-                                        LIGHT_GRAY_CONCRETE,
-                                        outline_x,
-                                        current_y,
-                                        outline_z,
-                                        None,
-                                        None,
-                                    );
-                                } else {
-                                    editor.set_block(
-                                        LIGHT_GRAY_CONCRETE,
-                                        outline_x,
-                                        current_y,
-                                        outline_z,
-                                        None,
-                                        None,
-                                    );
-                                }
+                                editor.set_block(
+                                    LIGHT_GRAY_CONCRETE,
+                                    outline_x,
+                                    current_y,
+                                    outline_z,
+                                    None,
+                                    None,
+                                );
                             }
                         }
 
@@ -605,25 +437,14 @@ fn generate_highways_internal(
                             if stripe_length < dash_length {
                                 let stripe_x: i32 = *x;
                                 let stripe_z: i32 = *z;
-                                if use_absolute_y {
-                                    editor.set_block_absolute(
-                                        WHITE_CONCRETE,
-                                        stripe_x,
-                                        current_y,
-                                        stripe_z,
-                                        Some(&[BLACK_CONCRETE]),
-                                        None,
-                                    );
-                                } else {
-                                    editor.set_block(
-                                        WHITE_CONCRETE,
-                                        stripe_x,
-                                        current_y,
-                                        stripe_z,
-                                        Some(&[BLACK_CONCRETE]),
-                                        None,
-                                    );
-                                }
+                                editor.set_block(
+                                    WHITE_CONCRETE,
+                                    stripe_x,
+                                    current_y,
+                                    stripe_z,
+                                    Some(&[BLACK_CONCRETE]),
+                                    None,
+                                );
                             }
 
                             // Increment stripe_length and reset after completing a dash and gap
@@ -767,46 +588,6 @@ fn add_highway_support_pillar(
     }
 }
 
-/// Add support pillars for bridges using absolute Y coordinates
-/// Pillars extend from ground level up to the bridge deck
-fn add_highway_support_pillar_absolute(
-    editor: &mut WorldEditor,
-    x: i32,
-    bridge_deck_y: i32,
-    z: i32,
-    dx: i32,
-    dz: i32,
-    _block_range: i32, // Keep for future use
-) {
-    // Only add pillars at specific intervals and positions
-    if dx == 0 && dz == 0 && (x + z) % 8 == 0 {
-        // Get the actual ground level at this position
-        let ground_y = editor.get_ground_level(x, z);
-
-        // Add pillar from ground up to bridge deck
-        // Only if the bridge is actually above the ground
-        if bridge_deck_y > ground_y {
-            for y in (ground_y + 1)..bridge_deck_y {
-                editor.set_block_absolute(STONE_BRICKS, x, y, z, None, None);
-            }
-
-            // Add pillar base at ground level
-            for base_dx in -1..=1 {
-                for base_dz in -1..=1 {
-                    editor.set_block_absolute(
-                        STONE_BRICKS,
-                        x + base_dx,
-                        ground_y,
-                        z + base_dz,
-                        None,
-                        None,
-                    );
-                }
-            }
-        }
-    }
-}
-
 /// Generates a siding using stone brick slabs
 pub fn generate_siding(editor: &mut WorldEditor, element: &ProcessedWay) {
     let mut previous_node: Option<XZPoint> = None;

src/elevation_data.rs

@@ -7,6 +7,8 @@ use std::path::{Path, PathBuf};
 
 /// Maximum Y coordinate in Minecraft (build height limit)
 const MAX_Y: i32 = 319;
+/// Scale factor for converting real elevation to Minecraft heights
+const BASE_HEIGHT_SCALE: f64 = 0.7;
 /// AWS S3 Terrarium tiles endpoint (no API key required)
 const AWS_TERRARIUM_URL: &str =
     "https://s3.amazonaws.com/elevation-tiles-prod/terrarium/{z}/{x}/{y}.png";
@@ -316,11 +318,16 @@ pub fn fetch_elevation_data(
     // This smooths terrain proportionally while preserving more detail.
     let sigma: f64 = BASE_SIGMA_REF * (grid_size / BASE_GRID_REF).sqrt();
 
-    //let blur_percentage: f64 = (sigma / grid_size) * 100.0;
-    /*eprintln!(
+    let blur_percentage: f64 = (sigma / grid_size) * 100.0;
+    eprintln!(
         "Elevation blur: grid={}x{}, sigma={:.2}, blur_percentage={:.2}%",
         grid_width, grid_height, sigma, blur_percentage
-    );*/
+    );
+
+    /* eprintln!(
+        "Grid: {}x{}, Blur sigma: {:.2}",
+        grid_width, grid_height, sigma
+    ); */
 
     // Continue with the existing blur and conversion to Minecraft heights...
     let blurred_heights: Vec<Vec<f64>> = apply_gaussian_blur(&height_grid, sigma);
@@ -351,7 +358,7 @@ pub fn fetch_elevation_data(
         }
     }
 
-    //eprintln!("Height data range: {min_height} to {max_height} m");
+    eprintln!("Height data range: {min_height} to {max_height} m");
     if extreme_low_count > 0 {
         eprintln!(
             "WARNING: Found {extreme_low_count} pixels with extremely low elevations (< -1000m)"
@@ -364,58 +371,35 @@ pub fn fetch_elevation_data(
     }
 
     let height_range: f64 = max_height - min_height;
+    // Apply scale factor to height scaling
+    let mut height_scale: f64 = BASE_HEIGHT_SCALE * scale.sqrt(); // sqrt to make height scaling less extreme
+    let mut scaled_range: f64 = height_range * height_scale;
 
-    // Realistic height scaling: 1 meter of real elevation = scale blocks in Minecraft
-    // At scale=1.0, 1 meter = 1 block (realistic 1:1 mapping)
-    // At scale=2.0, 1 meter = 2 blocks (exaggerated for larger worlds)
-    let ideal_scaled_range: f64 = height_range * scale;
+    // Adaptive scaling: ensure we don't exceed reasonable Y range
+    let available_y_range = (MAX_Y - ground_level) as f64;
+    let safety_margin = 0.9; // Use 90% of available range
+    let max_allowed_range = available_y_range * safety_margin;
 
-    // Calculate available Y range in Minecraft (from ground_level to MAX_Y)
-    // Leave a buffer at the top for buildings, trees, and other structures
-    const TERRAIN_HEIGHT_BUFFER: i32 = 15;
-    let available_y_range: f64 = (MAX_Y - TERRAIN_HEIGHT_BUFFER - ground_level) as f64;
-
-    // Determine final height scale:
-    // - Use realistic 1:1 (times scale) if terrain fits within Minecraft limits
-    // - Only compress if the terrain would exceed the build height
-    let scaled_range: f64 = if ideal_scaled_range <= available_y_range {
-        // Terrain fits! Use realistic scaling
+    if scaled_range > max_allowed_range {
+        let adjustment_factor = max_allowed_range / scaled_range;
+        height_scale *= adjustment_factor;
+        scaled_range = height_range * height_scale;
         eprintln!(
-            "Realistic elevation: {:.1}m range fits in {} available blocks",
-            height_range, available_y_range as i32
+            "Height range too large, applying scaling adjustment factor: {adjustment_factor:.3}"
         );
-        ideal_scaled_range
-    } else {
-        // Terrain too tall, compress to fit within Minecraft limits
-        let compression_factor: f64 = available_y_range / height_range;
-        let compressed_range: f64 = height_range * compression_factor;
-        eprintln!(
-            "Elevation compressed: {:.1}m range -> {:.0} blocks ({:.2}:1 ratio, 1 block = {:.2}m)",
-            height_range,
-            compressed_range,
-            height_range / compressed_range,
-            compressed_range / height_range
-        );
-        compressed_range
-    };
+        eprintln!("Adjusted scaled range: {scaled_range:.1} blocks");
+    }
 
     // Convert to scaled Minecraft Y coordinates
-    // Lowest real elevation maps to ground_level, highest maps to ground_level + scaled_range
     for row in blurred_heights {
         let mc_row: Vec<i32> = row
             .iter()
             .map(|&h| {
-                // Calculate relative position within the elevation range (0.0 to 1.0)
-                let relative_height: f64 = if height_range > 0.0 {
-                    (h - min_height) / height_range
-                } else {
-                    0.0
-                };
-                // Scale to Minecraft blocks and add to ground level
+                // Scale the height differences
+                let relative_height: f64 = (h - min_height) / height_range;
                 let scaled_height: f64 = relative_height * scaled_range;
-                // Clamp to valid Minecraft Y range (leave buffer at top for structures)
-                ((ground_level as f64 + scaled_height).round() as i32)
-                    .clamp(ground_level, MAX_Y - TERRAIN_HEIGHT_BUFFER)
+                // With terrain enabled, ground_level is used as the MIN_Y for terrain
+                ((ground_level as f64 + scaled_height).round() as i32).clamp(ground_level, MAX_Y)
             })
             .collect();
         mc_heights.push(mc_row);
@@ -429,7 +413,7 @@ pub fn fetch_elevation_data(
             max_block_height = max_block_height.max(height);
         }
     }
-    //eprintln!("Minecraft height data range: {min_block_height} to {max_block_height} blocks");
+    eprintln!("Minecraft height data range: {min_block_height} to {max_block_height} blocks");
 
     Ok(ElevationData {
         heights: mc_heights,
@@ -589,7 +573,7 @@ fn filter_elevation_outliers(height_grid: &mut [Vec<f64>]) {
     let min_reasonable = all_heights[p1_idx];
     let max_reasonable = all_heights[p99_idx];
 
-    //eprintln!("Filtering outliers outside range: {min_reasonable:.1}m to {max_reasonable:.1}m");
+    eprintln!("Filtering outliers outside range: {min_reasonable:.1}m to {max_reasonable:.1}m");
 
     let mut outliers_filtered = 0;
 
@@ -604,7 +588,7 @@ fn filter_elevation_outliers(height_grid: &mut [Vec<f64>]) {
     }
 
     if outliers_filtered > 0 {
-        //eprintln!("Filtered {outliers_filtered} elevation outliers, interpolating replacements...");
+        eprintln!("Filtered {outliers_filtered} elevation outliers, interpolating replacements...");
         // Re-run the NaN filling to interpolate the filtered values
         fill_nan_values(height_grid);
     }

src/gui.rs

@@ -1071,9 +1071,10 @@ fn gui_start_generation(
                     Ok(())
                 }
                 Err(e) => {
-                    emit_gui_error(&e.to_string());
+                    let error_msg = format!("Failed to fetch data: {e}");
+                    emit_gui_error(&error_msg);
                     // Session lock will be automatically released when _session_lock goes out of scope
-                    Err(e.to_string())
+                    Err(error_msg)
                 }
             }
         })

src/retrieve_data.rs

@@ -36,17 +36,19 @@ fn download_with_reqwest(url: &str, query: &str) -> Result<String, Box<dyn std::
         }
         Err(e) => {
             if e.is_timeout() {
-                let msg = "Request timed out. Try selecting a smaller area.";
-                eprintln!("{}", format!("Error! {msg}").red().bold());
-                Err(msg.into())
-            } else if e.is_connect() {
-                let msg = "No internet connection.";
-                eprintln!("{}", format!("Error! {msg}").red().bold());
-                Err(msg.into())
+                eprintln!(
+                    "{}",
+                    "Error! Request timed out. Try selecting a smaller area."
+                        .red()
+                        .bold()
+                );
+                emit_gui_error("Request timed out. Try selecting a smaller area.");
             } else {
                 eprintln!("{}", format!("Error! {e:.52}").red().bold());
-                Err(format!("{e:.52}").into())
+                emit_gui_error(&format!("{:.52}", e.to_string()));
             }
+            // Always propagate errors
+            Err(e.into())
         }
     }
 }

src/world_editor/java.rs

@@ -3,7 +3,7 @@
 //! This module handles saving worlds in the Java Edition Anvil (.mca) format.
 //! Supports streaming mode for memory-efficient saving of large worlds.
 
-use super::common::{Chunk, ChunkToModify, Section};
+use super::common::{Chunk, ChunkToModify, RegionToModify, Section};
 use super::WorldEditor;
 use crate::block_definitions::GRASS_BLOCK;
 use crate::progress::emit_gui_progress_update;
@@ -12,73 +12,21 @@ use fastanvil::Region;
 use fastnbt::Value;
 use fnv::FnvHashMap;
 use indicatif::{ProgressBar, ProgressStyle};
+use rayon::prelude::*;
 use std::collections::HashMap;
 use std::fs::File;
 use std::io::Write;
+use std::path::Path;
+use std::sync::atomic::{AtomicU64, Ordering};
 
 #[cfg(feature = "gui")]
 use crate::telemetry::{send_log, LogLevel};
 
 impl<'a> WorldEditor<'a> {
-    /// Creates a region file for the given region coordinates.
-    pub(super) fn create_region(&self, region_x: i32, region_z: i32) -> Region<File> {
-        let region_dir = self.world_dir.join("region");
-        let out_path = region_dir.join(format!("r.{}.{}.mca", region_x, region_z));
-
-        // Ensure region directory exists before creating region files
-        std::fs::create_dir_all(&region_dir).expect("Failed to create region directory");
-
-        const REGION_TEMPLATE: &[u8] = include_bytes!("../../assets/minecraft/region.template");
-
-        let mut region_file: File = File::options()
-            .read(true)
-            .write(true)
-            .create(true)
-            .truncate(true)
-            .open(&out_path)
-            .expect("Failed to open region file");
-
-        region_file
-            .write_all(REGION_TEMPLATE)
-            .expect("Could not write region template");
-
-        Region::from_stream(region_file).expect("Failed to load region")
-    }
-
-    /// Helper function to create a base chunk with grass blocks at Y -62
-    pub(super) fn create_base_chunk(abs_chunk_x: i32, abs_chunk_z: i32) -> (Vec<u8>, bool) {
-        let mut chunk = ChunkToModify::default();
-
-        // Fill the bottom layer with grass blocks at Y -62
-        for x in 0..16 {
-            for z in 0..16 {
-                chunk.set_block(x, -62, z, GRASS_BLOCK);
-            }
-        }
-
-        // Prepare chunk data
-        let chunk_data = Chunk {
-            sections: chunk.sections().collect(),
-            x_pos: abs_chunk_x,
-            z_pos: abs_chunk_z,
-            is_light_on: 0,
-            other: chunk.other,
-        };
-
-        // Create the Level wrapper
-        let level_data = create_level_wrapper(&chunk_data);
-
-        // Serialize the chunk with Level wrapper
-        let mut ser_buffer = Vec::with_capacity(8192);
-        fastnbt::to_writer(&mut ser_buffer, &level_data).unwrap();
-
-        (ser_buffer, true)
-    }
-
     /// Saves the world in Java Edition Anvil format.
     ///
-    /// Uses streaming mode: saves regions one at a time and releases memory after each,
-    /// significantly reducing peak memory usage for large worlds.
+    /// Uses parallel processing: saves multiple regions concurrently for faster I/O,
+    /// while still releasing memory after each region is processed.
     pub(super) fn save_java(&mut self) {
         println!("{} Saving world...", "[7/7]".bold());
         emit_gui_progress_update(90.0, "Saving world...");
@@ -92,6 +40,12 @@ impl<'a> WorldEditor<'a> {
         }
 
         let total_regions = self.world.regions.len() as u64;
+
+        // Early return if no regions to save (prevents division by zero)
+        if total_regions == 0 {
+            return;
+        }
+
         let save_pb = ProgressBar::new(total_regions);
         save_pb.set_style(
             ProgressStyle::default_bar()
@@ -102,155 +56,208 @@ impl<'a> WorldEditor<'a> {
                 .progress_chars("█▓░"),
         );
 
-        // Streaming mode: Process regions sequentially and release memory after each.
-        // This significantly reduces peak memory for large worlds (100+ regions).
-        // For small worlds, the overhead is negligible.
-        let mut regions_processed: u64 = 0;
+        // Ensure region directory exists before parallel processing
+        let region_dir = self.world_dir.join("region");
+        std::fs::create_dir_all(&region_dir).expect("Failed to create region directory");
 
-        // Collect region keys first to allow draining
-        let region_keys: Vec<(i32, i32)> = self.world.regions.keys().copied().collect();
+        // Drain all regions from memory into a Vec for parallel processing
+        let regions_to_save: Vec<((i32, i32), super::common::RegionToModify)> =
+            self.world.regions.drain().collect();
 
-        for (region_x, region_z) in region_keys {
-            // Remove region from memory - this is the key to memory savings
-            if let Some(region_to_modify) = self.world.regions.remove(&(region_x, region_z)) {
-                self.save_single_region(region_x, region_z, &region_to_modify);
+        // Track progress atomically across threads
+        let regions_processed = AtomicU64::new(0);
+        let world_dir = self.world_dir.clone();
+
+        // Process regions in parallel, each region file is independent
+        regions_to_save
+            .into_par_iter()
+            .for_each(|((region_x, region_z), region_to_modify)| {
+                // Save this region (creates its own file handle)
+                save_region_to_file(&world_dir, region_x, region_z, &region_to_modify);
+
+                // Update progress atomically
+                let processed = regions_processed.fetch_add(1, Ordering::Relaxed) + 1;
+                save_pb.inc(1);
+
+                // Emit GUI progress update periodically
+                let update_interval = (total_regions / 10).max(1);
+                if processed.is_multiple_of(update_interval) || processed == total_regions {
+                    let progress = 90.0 + (processed as f64 / total_regions as f64) * 9.0;
+                    emit_gui_progress_update(progress, "Saving world...");
+                }
 
                 // Region memory is freed when region_to_modify goes out of scope here
-            }
-
-            regions_processed += 1;
-
-            // Update progress at regular intervals
-            let update_interval = (total_regions / 10).max(1);
-            if regions_processed.is_multiple_of(update_interval)
-                || regions_processed == total_regions
-            {
-                let progress = 90.0 + (regions_processed as f64 / total_regions as f64) * 9.0;
-                emit_gui_progress_update(progress, "Saving world...");
-            }
-
-            save_pb.inc(1);
-        }
+            });
 
         save_pb.finish();
     }
+}
 
-    /// Saves a single region to disk.
-    ///
-    /// This is extracted to allow streaming mode to save and release regions one at a time.
-    fn save_single_region(
-        &self,
-        region_x: i32,
-        region_z: i32,
-        region_to_modify: &super::common::RegionToModify,
-    ) {
-        let mut region = self.create_region(region_x, region_z);
-        let mut ser_buffer = Vec::with_capacity(8192);
+/// Saves a single region to a file (thread-safe, for parallel processing).
+///
+/// This is a standalone function that can be called from parallel threads
+/// since it only needs the world directory path, not a reference to WorldEditor.
+fn save_region_to_file(
+    world_dir: &Path,
+    region_x: i32,
+    region_z: i32,
+    region_to_modify: &RegionToModify,
+) {
+    // Create region file
+    let region_dir = world_dir.join("region");
+    let out_path = region_dir.join(format!("r.{}.{}.mca", region_x, region_z));
 
-        for (&(chunk_x, chunk_z), chunk_to_modify) in &region_to_modify.chunks {
-            if !chunk_to_modify.sections.is_empty() || !chunk_to_modify.other.is_empty() {
-                // Read existing chunk data if it exists
-                let existing_data = region
-                    .read_chunk(chunk_x as usize, chunk_z as usize)
-                    .unwrap()
-                    .unwrap_or_default();
+    const REGION_TEMPLATE: &[u8] = include_bytes!("../../assets/minecraft/region.template");
 
-                // Parse existing chunk or create new one
-                let mut chunk: Chunk = if !existing_data.is_empty() {
-                    fastnbt::from_bytes(&existing_data).unwrap()
+    let mut region_file: File = File::options()
+        .read(true)
+        .write(true)
+        .create(true)
+        .truncate(true)
+        .open(&out_path)
+        .expect("Failed to open region file");
+
+    region_file
+        .write_all(REGION_TEMPLATE)
+        .expect("Could not write region template");
+
+    let mut region = Region::from_stream(region_file).expect("Failed to load region");
+    let mut ser_buffer = Vec::with_capacity(8192);
+
+    // First pass: write modified chunks
+    for (&(chunk_x, chunk_z), chunk_to_modify) in &region_to_modify.chunks {
+        if !chunk_to_modify.sections.is_empty() || !chunk_to_modify.other.is_empty() {
+            // Read existing chunk data if it exists
+            let existing_data = region
+                .read_chunk(chunk_x as usize, chunk_z as usize)
+                .unwrap()
+                .unwrap_or_default();
+
+            // Parse existing chunk or create new one
+            let mut chunk: Chunk = if !existing_data.is_empty() {
+                fastnbt::from_bytes(&existing_data).unwrap()
+            } else {
+                Chunk {
+                    sections: Vec::new(),
+                    x_pos: chunk_x + (region_x * 32),
+                    z_pos: chunk_z + (region_z * 32),
+                    is_light_on: 0,
+                    other: FnvHashMap::default(),
+                }
+            };
+
+            // Update sections while preserving existing data
+            let new_sections: Vec<Section> = chunk_to_modify.sections().collect();
+            for new_section in new_sections {
+                if let Some(existing_section) =
+                    chunk.sections.iter_mut().find(|s| s.y == new_section.y)
+                {
+                    // Merge block states
+                    existing_section.block_states.palette = new_section.block_states.palette;
+                    existing_section.block_states.data = new_section.block_states.data;
                 } else {
-                    Chunk {
-                        sections: Vec::new(),
-                        x_pos: chunk_x + (region_x * 32),
-                        z_pos: chunk_z + (region_z * 32),
-                        is_light_on: 0,
-                        other: FnvHashMap::default(),
-                    }
-                };
+                    // Add new section if it doesn't exist
+                    chunk.sections.push(new_section);
+                }
+            }
 
-                // Update sections while preserving existing data
-                let new_sections: Vec<Section> = chunk_to_modify.sections().collect();
-                for new_section in new_sections {
-                    if let Some(existing_section) =
-                        chunk.sections.iter_mut().find(|s| s.y == new_section.y)
+            // Preserve existing block entities and merge with new ones
+            if let Some(existing_entities) = chunk.other.get_mut("block_entities") {
+                if let Some(new_entities) = chunk_to_modify.other.get("block_entities") {
+                    if let (Value::List(existing), Value::List(new)) =
+                        (existing_entities, new_entities)
                     {
-                        // Merge block states
-                        existing_section.block_states.palette = new_section.block_states.palette;
-                        existing_section.block_states.data = new_section.block_states.data;
-                    } else {
-                        // Add new section if it doesn't exist
-                        chunk.sections.push(new_section);
+                        // Remove old entities that are replaced by new ones
+                        existing.retain(|e| {
+                            if let Value::Compound(map) = e {
+                                let (x, y, z) = get_entity_coords(map);
+                                !new.iter().any(|new_e| {
+                                    if let Value::Compound(new_map) = new_e {
+                                        let (nx, ny, nz) = get_entity_coords(new_map);
+                                        x == nx && y == ny && z == nz
+                                    } else {
+                                        false
+                                    }
+                                })
+                            } else {
+                                true
+                            }
+                        });
+                        // Add new entities
+                        existing.extend(new.clone());
                     }
                 }
-
-                // Preserve existing block entities and merge with new ones
-                if let Some(existing_entities) = chunk.other.get_mut("block_entities") {
-                    if let Some(new_entities) = chunk_to_modify.other.get("block_entities") {
-                        if let (Value::List(existing), Value::List(new)) =
-                            (existing_entities, new_entities)
-                        {
-                            // Remove old entities that are replaced by new ones
-                            existing.retain(|e| {
-                                if let Value::Compound(map) = e {
-                                    let (x, y, z) = get_entity_coords(map);
-                                    !new.iter().any(|new_e| {
-                                        if let Value::Compound(new_map) = new_e {
-                                            let (nx, ny, nz) = get_entity_coords(new_map);
-                                            x == nx && y == ny && z == nz
-                                        } else {
-                                            false
-                                        }
-                                    })
-                                } else {
-                                    true
-                                }
-                            });
-                            // Add new entities
-                            existing.extend(new.clone());
-                        }
-                    }
-                } else {
-                    // If no existing entities, just add the new ones
-                    if let Some(new_entities) = chunk_to_modify.other.get("block_entities") {
-                        chunk
-                            .other
-                            .insert("block_entities".to_string(), new_entities.clone());
-                    }
+            } else {
+                // If no existing entities, just add the new ones
+                if let Some(new_entities) = chunk_to_modify.other.get("block_entities") {
+                    chunk
+                        .other
+                        .insert("block_entities".to_string(), new_entities.clone());
                 }
+            }
 
-                // Update chunk coordinates and flags
-                chunk.x_pos = chunk_x + (region_x * 32);
-                chunk.z_pos = chunk_z + (region_z * 32);
+            // Update chunk coordinates and flags
+            chunk.x_pos = chunk_x + (region_x * 32);
+            chunk.z_pos = chunk_z + (region_z * 32);
 
-                // Create Level wrapper and save
-                let level_data = create_level_wrapper(&chunk);
-                ser_buffer.clear();
-                fastnbt::to_writer(&mut ser_buffer, &level_data).unwrap();
+            // Create Level wrapper and save
+            let level_data = create_level_wrapper(&chunk);
+            ser_buffer.clear();
+            fastnbt::to_writer(&mut ser_buffer, &level_data).unwrap();
+            region
+                .write_chunk(chunk_x as usize, chunk_z as usize, &ser_buffer)
+                .unwrap();
+        }
+    }
+
+    // Second pass: ensure all chunks exist (create base chunks for empty slots)
+    for chunk_x in 0..32 {
+        for chunk_z in 0..32 {
+            let abs_chunk_x = chunk_x + (region_x * 32);
+            let abs_chunk_z = chunk_z + (region_z * 32);
+
+            // Check if chunk exists in our modifications
+            let chunk_exists = region_to_modify.chunks.contains_key(&(chunk_x, chunk_z));
+
+            // If chunk doesn't exist, create it with base layer
+            if !chunk_exists {
+                let (ser_buffer, _) = create_base_chunk(abs_chunk_x, abs_chunk_z);
                 region
                     .write_chunk(chunk_x as usize, chunk_z as usize, &ser_buffer)
                     .unwrap();
             }
         }
+    }
+}
 
-        // Second pass: ensure all chunks exist
-        for chunk_x in 0..32 {
-            for chunk_z in 0..32 {
-                let abs_chunk_x = chunk_x + (region_x * 32);
-                let abs_chunk_z = chunk_z + (region_z * 32);
+/// Helper function to create a base chunk with grass blocks at Y -62 (standalone version)
+fn create_base_chunk(abs_chunk_x: i32, abs_chunk_z: i32) -> (Vec<u8>, bool) {
+    let mut chunk = ChunkToModify::default();
 
-                // Check if chunk exists in our modifications
-                let chunk_exists = region_to_modify.chunks.contains_key(&(chunk_x, chunk_z));
-
-                // If chunk doesn't exist, create it with base layer
-                if !chunk_exists {
-                    let (ser_buffer, _) = Self::create_base_chunk(abs_chunk_x, abs_chunk_z);
-                    region
-                        .write_chunk(chunk_x as usize, chunk_z as usize, &ser_buffer)
-                        .unwrap();
-                }
-            }
+    // Fill the bottom layer with grass blocks at Y -62
+    for x in 0..16 {
+        for z in 0..16 {
+            chunk.set_block(x, -62, z, GRASS_BLOCK);
         }
     }
+
+    // Prepare chunk data
+    let chunk_data = Chunk {
+        sections: chunk.sections().collect(),
+        x_pos: abs_chunk_x,
+        z_pos: abs_chunk_z,
+        is_light_on: 0,
+        other: chunk.other,
+    };
+
+    // Create the Level wrapper
+    let level_data = create_level_wrapper(&chunk_data);
+
+    // Serialize the chunk with Level wrapper
+    let mut ser_buffer = Vec::with_capacity(8192);
+    fastnbt::to_writer(&mut ser_buffer, &level_data).unwrap();
+
+    (ser_buffer, true)
 }
 
 /// Helper function to get entity coordinates

src/world_editor/mod.rs

@@ -151,19 +151,6 @@ impl<'a> WorldEditor<'a> {
         }
     }
 
-    /// Get the ground level at a specific world coordinate (without any offset)
-    #[inline(always)]
-    pub fn get_ground_level(&self, x: i32, z: i32) -> i32 {
-        if let Some(ground) = &self.ground {
-            ground.level(XZPoint::new(
-                x - self.xzbbox.min_x(),
-                z - self.xzbbox.min_z(),
-            ))
-        } else {
-            0 // Default ground level if no terrain data
-        }
-    }
-
     /// Returns the minimum world coordinates
     pub fn get_min_coords(&self) -> (i32, i32) {
         (self.xzbbox.min_x(), self.xzbbox.min_z())