removed duplicated code and did some spring cleaning

src/exporter.rs

@@ -276,12 +276,22 @@ fn render_pixmap(layout: &DungeonLayout, settings: &UiSettings) -> Result<Pixmap
         draw_window(&mut pixmap, &g, window, door_w, WINDOW, style);
     }
 
-    for marker in &layout.start_markers {
+    draw_area_marker_group(
-        draw_area_marker(&mut pixmap, &g, marker, "S", START_MARKER, settings.colorblind_mode);
+        &mut pixmap,
-    }
+        &g,
-    for marker in &layout.end_markers {
+        &layout.start_markers,
-        draw_area_marker(&mut pixmap, &g, marker, "E", END_MARKER, settings.colorblind_mode);
+        "S",
-    }
+        START_MARKER,
+        settings.colorblind_mode,
+    );
+    draw_area_marker_group(
+        &mut pixmap,
+        &g,
+        &layout.end_markers,
+        "E",
+        END_MARKER,
+        settings.colorblind_mode,
+    );
 
     Ok(pixmap)
 }
@@ -352,12 +362,8 @@ fn export_composite_masks(
     for window in &layout.windows {
         draw_window(&mut windows, &g, window, door_w, WHITE, DoorStyle::Solid);
     }
-    for marker in &layout.start_markers {
+    fill_marker_mask(&mut start_markers, &g, &layout.start_markers);
-        fill_rect_marker(&mut start_markers, &g, marker, WHITE);
+    fill_marker_mask(&mut end_markers, &g, &layout.end_markers);
-    }
-    for marker in &layout.end_markers {
-        fill_rect_marker(&mut end_markers, &g, marker, WHITE);
-    }
 
     let composite = render_pixmap(layout, settings)?;
     let composite_img = raster_image_from_pixmap(&composite, settings)?;
@@ -394,6 +400,12 @@ fn blank_mask(g: &ExportGeometry, name: &str) -> Result<Pixmap, String> {
     Ok(pixmap)
 }
 
+fn fill_marker_mask(pixmap: &mut Pixmap, g: &ExportGeometry, markers: &[AreaMarker]) {
+    for marker in markers {
+        fill_rect_marker(pixmap, g, marker, WHITE);
+    }
+}
+
 // Write a single mask image to disk.
 fn save_mask_image(
     folder: &std::path::Path,
@@ -684,12 +696,22 @@ fn build_svg(layout: &DungeonLayout, settings: &UiSettings) -> String {
         }
     }
 
-    for marker in &layout.start_markers {
+    append_svg_area_marker_group(
-        append_svg_area_marker(&mut s, &g, marker, "S", START_MARKER, settings.colorblind_mode);
+        &mut s,
-    }
+        &g,
-    for marker in &layout.end_markers {
+        &layout.start_markers,
-        append_svg_area_marker(&mut s, &g, marker, "E", END_MARKER, settings.colorblind_mode);
+        "S",
-    }
+        START_MARKER,
+        settings.colorblind_mode,
+    );
+    append_svg_area_marker_group(
+        &mut s,
+        &g,
+        &layout.end_markers,
+        "E",
+        END_MARKER,
+        settings.colorblind_mode,
+    );
 
     s.push_str("</svg>\n");
     s
@@ -854,6 +876,19 @@ fn draw_area_marker(
     }
 }
 
+fn draw_area_marker_group(
+    pixmap: &mut Pixmap,
+    g: &ExportGeometry,
+    markers: &[AreaMarker],
+    label: &str,
+    color: (u8, u8, u8, u8),
+    colorblind_mode: bool,
+) {
+    for marker in markers {
+        draw_area_marker(pixmap, g, marker, label, color, colorblind_mode);
+    }
+}
+
 // Draw a filled circle for dot patterns.
 fn draw_dot(pixmap: &mut Pixmap, cx: f32, cy: f32, radius: f32, color: (u8, u8, u8, u8)) {
     let mut pb = PathBuilder::new();
@@ -1165,6 +1200,19 @@ fn append_svg_area_marker(
     }
 }
 
+fn append_svg_area_marker_group(
+    out: &mut String,
+    g: &ExportGeometry,
+    markers: &[AreaMarker],
+    label: &str,
+    color: (u8, u8, u8, u8),
+    colorblind_mode: bool,
+) {
+    for marker in markers {
+        append_svg_area_marker(out, g, marker, label, color, colorblind_mode);
+    }
+}
+
 // Draw a door line onto the pixmap.
 fn draw_door(
     pixmap: &mut Pixmap,

src/main.rs

@@ -285,6 +285,22 @@ fn clamp_dependent_settings(settings: &mut UiSettings) {
 }
 
 impl DungeonApp {
+    fn clear_hover_targets(&mut self) {
+        self.hover_room_idx = None;
+        self.hover_corridor_idx = None;
+        self.hover_door_idx = None;
+        self.hover_text_idx = None;
+        self.hover_marker = None;
+    }
+
+    fn reset_transient_state(&mut self) {
+        self.drag_state = None;
+        self.add_corridor_drag = None;
+        self.resize_state = None;
+        self.clear_hover_targets();
+        self.pending_delete = false;
+    }
+
     fn snapshot(&self) -> AppSnapshot {
         AppSnapshot {
             settings: self.settings.clone(),
@@ -309,15 +325,7 @@ impl DungeonApp {
         self.settings = snapshot.settings;
         self.layout = snapshot.layout;
         self.suppressed_auto_door_edges = snapshot.suppressed_auto_door_edges;
-        self.drag_state = None;
+        self.reset_transient_state();
-        self.add_corridor_drag = None;
-        self.resize_state = None;
-        self.hover_room_idx = None;
-        self.hover_corridor_idx = None;
-        self.hover_door_idx = None;
-        self.hover_text_idx = None;
-        self.hover_marker = None;
-        self.pending_delete = false;
     }
 
     fn undo(&mut self) {
@@ -343,15 +351,7 @@ impl DungeonApp {
             ..DungeonLayout::default()
         };
         self.suppressed_auto_door_edges.clear();
-        self.drag_state = None;
+        self.reset_transient_state();
-        self.add_corridor_drag = None;
-        self.resize_state = None;
-        self.hover_room_idx = None;
-        self.hover_corridor_idx = None;
-        self.hover_door_idx = None;
-        self.hover_text_idx = None;
-        self.hover_marker = None;
-        self.pending_delete = false;
     }
 
     // Regenerate the dungeon layout from current settings and reset drag state.
@@ -868,11 +868,7 @@ impl DungeonApp {
     // Update which room/corridor/door is currently hovered.
     fn update_hover_targets(&mut self, ctx: &egui::Context, geometry: &GridGeometry) {
         let Some(pointer_pos) = ctx.pointer_hover_pos() else {
-            self.hover_room_idx = None;
+            self.clear_hover_targets();
-            self.hover_corridor_idx = None;
-            self.hover_door_idx = None;
-            self.hover_text_idx = None;
-            self.hover_marker = None;
             return;
         };
         if let Some(edge) = self.door_edge_at_pointer(pointer_pos, geometry) {
@@ -1941,28 +1937,26 @@ fn draw_layout(
         );
     }
 
-    for (idx, marker) in layout.start_markers.iter().enumerate() {
+    draw_area_marker_group(
-        draw_area_marker(
+        painter,
-            painter,
+        geometry,
-            geometry,
+        &layout.start_markers,
-            marker,
+        "S",
-            "S",
+        Color32::from_rgb(60, 220, 200),
-            Color32::from_rgb(60, 220, 200),
+        colorblind_mode,
-            colorblind_mode,
+        hover_marker,
-            hover_marker == Some(HoverMarker::Start(idx)),
+        MarkerKind::Start,
-        );
+    );
-    }
+    draw_area_marker_group(
-    for (idx, marker) in layout.end_markers.iter().enumerate() {
+        painter,
-        draw_area_marker(
+        geometry,
-            painter,
+        &layout.end_markers,
-            geometry,
+        "E",
-            marker,
+        Color32::from_rgb(240, 90, 90),
-            "E",
+        colorblind_mode,
-            Color32::from_rgb(240, 90, 90),
+        hover_marker,
-            colorblind_mode,
+        MarkerKind::End,
-            hover_marker == Some(HoverMarker::End(idx)),
+    );
-        );
-    }
 }
 
 // Compute the rectangle for a given grid cell.
@@ -2051,6 +2045,34 @@ fn draw_area_marker(
     );
 }
 
+fn draw_area_marker_group(
+    painter: &egui::Painter,
+    geometry: &GridGeometry,
+    markers: &[layout::AreaMarker],
+    label: &str,
+    base_color: Color32,
+    colorblind_mode: bool,
+    hover_marker: Option<HoverMarker>,
+    kind: MarkerKind,
+) {
+    for (idx, marker) in markers.iter().enumerate() {
+        let hovered = match (kind, hover_marker) {
+            (MarkerKind::Start, Some(HoverMarker::Start(hover_idx))) => hover_idx == idx,
+            (MarkerKind::End, Some(HoverMarker::End(hover_idx))) => hover_idx == idx,
+            _ => false,
+        };
+        draw_area_marker(
+            painter,
+            geometry,
+            marker,
+            label,
+            base_color,
+            colorblind_mode,
+            hovered,
+        );
+    }
+}
+
 // Draw a rectangular wall segment between two points.
 fn draw_wall_segment(
     painter: &egui::Painter,

src/startend.rs

@@ -59,37 +59,30 @@ pub fn populate_random_markers(
         consume_room(&mut available_end_rooms, end_room_idx);
     }
 
-    for idx in pair_count..start_count {
+    assign_extra_markers(
-        let room_idx = pick_room_index(
+        &mut layout.start_markers,
-            &available_start_rooms,
+        &layout.rooms,
-            layout.rooms.len(),
+        &mut available_start_rooms,
-            seed::derive_seed(settings.seed, EXTRA_START_ROOM_STREAM_BASE + idx as u64),
+        pair_count,
-        );
+        start_count,
-        let room = &layout.rooms[room_idx];
+        settings.min_start_marker_size,
-        layout.start_markers.push(marker_in_room(
+        settings.max_start_marker_size,
-            room,
+        settings.seed,
-            settings.min_start_marker_size,
+        EXTRA_START_ROOM_STREAM_BASE,
-            settings.max_start_marker_size,
+        EXTRA_START_MARKER_STREAM_BASE,
-            seed::derive_seed(settings.seed, EXTRA_START_MARKER_STREAM_BASE + idx as u64),
+    );
-        ));
+    assign_extra_markers(
-        consume_room(&mut available_start_rooms, room_idx);
+        &mut layout.end_markers,
-    }
+        &layout.rooms,
-
+        &mut available_end_rooms,
-    for idx in pair_count..end_count {
+        pair_count,
-        let room_idx = pick_room_index(
+        end_count,
-            &available_end_rooms,
+        settings.min_end_marker_size,
-            layout.rooms.len(),
+        settings.max_end_marker_size,
-            seed::derive_seed(settings.seed, EXTRA_END_ROOM_STREAM_BASE + idx as u64),
+        settings.seed,
-        );
+        EXTRA_END_ROOM_STREAM_BASE,
-        let room = &layout.rooms[room_idx];
+        EXTRA_END_MARKER_STREAM_BASE,
-        layout.end_markers.push(marker_in_room(
+    );
-            room,
-            settings.min_end_marker_size,
-            settings.max_end_marker_size,
-            seed::derive_seed(settings.seed, EXTRA_END_MARKER_STREAM_BASE + idx as u64),
-        ));
-        consume_room(&mut available_end_rooms, room_idx);
-    }
 
     layout
 }
@@ -142,6 +135,34 @@ fn marker_in_room(
     layout::AreaMarker { cell: (x, y), size }
 }
 
+fn assign_extra_markers(
+    markers: &mut Vec<layout::AreaMarker>,
+    rooms: &[layout::Room],
+    available_rooms: &mut Vec<usize>,
+    start_idx: usize,
+    end_idx: usize,
+    min_size: usize,
+    max_size: usize,
+    seed_base: u64,
+    room_stream_base: u64,
+    marker_stream_base: u64,
+) {
+    for idx in start_idx..end_idx {
+        let room_idx = pick_room_index(
+            available_rooms,
+            rooms.len(),
+            seed::derive_seed(seed_base, room_stream_base + idx as u64),
+        );
+        markers.push(marker_in_room(
+            &rooms[room_idx],
+            min_size,
+            max_size,
+            seed::derive_seed(seed_base, marker_stream_base + idx as u64),
+        ));
+        consume_room(available_rooms, room_idx);
+    }
+}
+
 // Match each start/end pair to the farthest available room combination.
 fn farthest_room_pair(
     rooms: &[layout::Room],