Initial implementation

1 files changed, 823 insertions, 0 deletions

diff --git a/src/renderer.rs b/src/renderer.rs
new file mode 100644
index 0000000..9991d56
--- /dev/null
+++ b/src/renderer.rs
@@ -0,0 +1,823 @@
+use std::io::Cursor;
+use wmap_parser::Map;
+
+use crate::configuration::Configuration;
+use crate::stage_type::StageType;
+use crate::utils::{percent_to_pixel, set_color};
+use crate::RenderError;
+
+/// Renders a map to PNG format
+pub fn render_to_png(
+    map: &Map,
+    stage_type: StageType,
+    config: &Configuration,
+) -> Result<Vec<u8>, RenderError> {
+    let total_width = (config.theme.sizes.map_width + config.theme.sizes.padding * 2.0) as i32;
+    let total_height = (config.theme.sizes.map_height
+        + config.theme.sizes.padding
+        + config.theme.sizes.bottom_padding) as i32;
+
+    let surface = cairo::ImageSurface::create(cairo::Format::ARgb32, total_width, total_height)?;
+    let ctx = cairo::Context::new(&surface)?;
+
+    render(&ctx, map, stage_type, config)?;
+
+    let mut buffer = Cursor::new(Vec::new());
+    surface.write_to_png(&mut buffer)?;
+    Ok(buffer.into_inner())
+}
+
+/// Renders a map to SVG format
+pub fn render_to_svg(
+    map: &Map,
+    stage_type: StageType,
+    config: &Configuration,
+) -> Result<String, RenderError> {
+    use std::fs;
+    use tempfile::NamedTempFile;
+
+    let total_width = config.theme.sizes.map_width + config.theme.sizes.padding * 2.0;
+    let total_height = config.theme.sizes.map_height
+        + config.theme.sizes.padding
+        + config.theme.sizes.bottom_padding;
+
+    let temp_file = NamedTempFile::new()?;
+    let path = temp_file
+        .path()
+        .to_str()
+        .ok_or_else(|| RenderError::InvalidConfig("Failed to create temp file path".to_string()))?;
+
+    let surface = cairo::SvgSurface::new(total_width, total_height, Some(path))?;
+    let ctx = cairo::Context::new(&surface)?;
+
+    render(&ctx, map, stage_type, config)?;
+
+    drop(ctx);
+    surface.finish();
+
+    let svg_content = fs::read_to_string(path)?;
+    Ok(svg_content)
+}
+
+/// Core rendering function
+fn render(
+    ctx: &cairo::Context,
+    map: &Map,
+    stage_type: StageType,
+    config: &Configuration,
+) -> Result<(), RenderError> {
+    // Apply padding transform
+    ctx.save()?;
+    ctx.translate(config.theme.sizes.padding, config.theme.sizes.padding);
+
+    // Render in order (back to front)
+    draw_background(ctx, config)?;
+
+    if config.options.show_background {
+        draw_stage_patterns(ctx, stage_type, map, config)?;
+    }
+
+    draw_axes(ctx, stage_type, map, config)?;
+    draw_stage_dividers(ctx, map, config)?;
+    draw_dependencies(ctx, map, config)?;
+    draw_groups(ctx, map, config)?;
+    draw_vertices(ctx, map, config)?;
+    draw_vertex_labels(ctx, map, config)?;
+    draw_inertias(ctx, map, config)?;
+    draw_evolutions(ctx, map, config)?;
+    draw_notes(ctx, map, config)?;
+
+    ctx.restore()?;
+    Ok(())
+}
+
+fn draw_background(ctx: &cairo::Context, config: &Configuration) -> Result<(), RenderError> {
+    ctx.save()?;
+    set_color(ctx, &config.theme.colors.background);
+    ctx.paint()?;
+    ctx.restore()?;
+    Ok(())
+}
+
+fn draw_stage_patterns(
+    ctx: &cairo::Context,
+    _stage_type: StageType,
+    map: &Map,
+    config: &Configuration,
+) -> Result<(), RenderError> {
+    use crate::patterns::{create_pattern, SHADOW_GRID, SHINGLES, STITCH, WICKER};
+
+    let stages = get_stage_positions(map, config);
+    let patterns = [
+        create_pattern(
+            &STITCH,
+            &config.theme.colors.stage_foreground,
+            &config.theme.colors.stage_background,
+        )?,
+        create_pattern(
+            &SHINGLES,
+            &config.theme.colors.stage_foreground,
+            &config.theme.colors.stage_background,
+        )?,
+        create_pattern(
+            &SHADOW_GRID,
+            &config.theme.colors.stage_foreground,
+            &config.theme.colors.stage_background,
+        )?,
+        create_pattern(
+            &WICKER,
+            &config.theme.colors.stage_foreground,
+            &config.theme.colors.stage_background,
+        )?,
+    ];
+
+    ctx.save()?;
+
+    // Draw pattern for stage 0 to stage 1
+    ctx.rectangle(0.0, 0.0, stages[0], config.theme.sizes.map_height);
+    ctx.set_source(&patterns[0])?;
+    ctx.fill()?;
+
+    // Draw pattern for stage 1 to stage 2
+    ctx.rectangle(
+        stages[0],
+        0.0,
+        stages[1] - stages[0],
+        config.theme.sizes.map_height,
+    );
+    ctx.set_source(&patterns[1])?;
+    ctx.fill()?;
+
+    // Draw pattern for stage 2 to stage 3
+    ctx.rectangle(
+        stages[1],
+        0.0,
+        stages[2] - stages[1],
+        config.theme.sizes.map_height,
+    );
+    ctx.set_source(&patterns[2])?;
+    ctx.fill()?;
+
+    // Draw pattern for stage 3 to end
+    ctx.rectangle(
+        stages[2],
+        0.0,
+        config.theme.sizes.map_width - stages[2],
+        config.theme.sizes.map_height,
+    );
+    ctx.set_source(&patterns[3])?;
+    ctx.fill()?;
+
+    ctx.restore()?;
+    Ok(())
+}
+
+fn draw_axes(
+    ctx: &cairo::Context,
+    stage_type: StageType,
+    map: &Map,
+    config: &Configuration,
+) -> Result<(), RenderError> {
+    use std::f64::consts::PI;
+
+    let sizes = &config.theme.sizes;
+    let fonts = &config.theme.fonts;
+
+    ctx.save()?;
+    set_color(ctx, &config.theme.colors.axis);
+    ctx.set_line_width(sizes.line_width * 2.0);
+
+    // Y-axis and X-axis
+    ctx.move_to(0.0, 0.0);
+    ctx.line_to(0.0, sizes.map_height);
+    ctx.line_to(sizes.map_width, sizes.map_height);
+    ctx.stroke()?;
+
+    // Text setup
+    set_color(ctx, &config.theme.colors.label);
+    ctx.select_font_face(
+        "sans-serif",
+        cairo::FontSlant::Normal,
+        cairo::FontWeight::Normal,
+    );
+    ctx.set_font_size(fonts.axis_label);
+    ctx.set_line_width(1.0);
+
+    // Y-axis labels (rotated -90 degrees)
+    ctx.save()?;
+    ctx.translate(-20.0, 45.0);
+    ctx.rotate(-PI / 2.0);
+    ctx.move_to(0.0, 0.0);
+    ctx.show_text("Visible")?;
+    ctx.restore()?;
+
+    ctx.save()?;
+    ctx.translate(-20.0, sizes.map_height);
+    ctx.rotate(-PI / 2.0);
+    ctx.move_to(0.0, 0.0);
+    ctx.show_text("Invisible")?;
+    ctx.restore()?;
+
+    // X-axis labels (above the map, at negative Y, offset by half vertex height)
+    let stage_height = sizes.stage_height;
+    let text_offset_y = -stage_height / 4.0 + sizes.vertex_size / 2.0;
+    ctx.move_to(0.0, text_offset_y);
+    ctx.show_text("Uncharted")?;
+
+    let text_ext = ctx.text_extents("Industrialised")?;
+    ctx.move_to(sizes.map_width - text_ext.width(), text_offset_y);
+    ctx.show_text("Industrialised")?;
+
+    // Stage labels (below the map, offset by half vertex height, with text wrapping)
+    let stage_labels = stage_type.stages();
+    let stages = get_stage_positions(map, config);
+    let padding = 5.0; // kAxisLabelPadding
+    let stage_label_y = sizes.map_height + padding + sizes.vertex_size / 2.0;
+    let line_height = fonts.axis_label * 1.2; // 120% line height
+
+    // Calculate widths for each stage
+    let stage_widths = [
+        stages[0],
+        stages[1] - stages[0],
+        stages[2] - stages[1],
+        sizes.map_width - stages[2],
+    ];
+
+    // Draw each stage label with wrapping
+    for (i, &label) in stage_labels.iter().enumerate() {
+        let x = match i {
+            0 => 0.0,
+            1 => stages[0],
+            2 => stages[1],
+            3 => stages[2],
+            _ => continue,
+        };
+
+        let wrapped_lines = wrap_text(ctx, label, stage_widths[i])?;
+
+        for (line_index, line) in wrapped_lines.iter().enumerate() {
+            let y = stage_label_y + line_index as f64 * line_height;
+            ctx.move_to(x, y);
+            ctx.show_text(line)?;
+        }
+    }
+
+    ctx.restore()?;
+    Ok(())
+}
+
+fn draw_stage_dividers(
+    ctx: &cairo::Context,
+    map: &Map,
+    config: &Configuration,
+) -> Result<(), RenderError> {
+    let stages = get_stage_positions(map, config);
+
+    ctx.save()?;
+    set_color(ctx, &config.theme.colors.axis);
+    ctx.set_line_width(config.theme.sizes.line_width * 2.0);
+    ctx.set_dash(&[10.0, 18.0], 0.0);
+
+    for &stage_x in &stages {
+        ctx.move_to(stage_x, 0.0);
+        ctx.line_to(stage_x, config.theme.sizes.map_height);
+    }
+
+    ctx.stroke()?;
+    ctx.restore()?;
+    Ok(())
+}
+
+fn draw_dependencies(
+    ctx: &cairo::Context,
+    map: &Map,
+    config: &Configuration,
+) -> Result<(), RenderError> {
+    use std::collections::HashMap;
+    use std::f64::consts::PI;
+
+    // Build component map for fast lookup
+    let mut component_map: HashMap<String, (f64, f64)> = HashMap::new();
+    for component in &map.components {
+        let x = percent_to_pixel(component.coordinates.0, config.theme.sizes.map_width);
+        let y = percent_to_pixel(component.coordinates.1, config.theme.sizes.map_height);
+        component_map.insert(component.label.to_lowercase(), (x, y));
+    }
+
+    ctx.save()?;
+    set_color(ctx, &config.theme.colors.vertex);
+    ctx.set_line_width(config.theme.sizes.line_width);
+
+    let half_width = config.theme.sizes.vertex_size / 2.0;
+    let half_height = config.theme.sizes.vertex_size / 2.0;
+    let arrow_angle = PI / 4.0; // 45 degrees
+
+    for dependency in &map.dependencies {
+        let from_coords = match component_map.get(&dependency.from.to_lowercase()) {
+            Some(coords) => coords,
+            None => continue,
+        };
+        let to_coords = match component_map.get(&dependency.to.to_lowercase()) {
+            Some(coords) => coords,
+            None => continue,
+        };
+
+        let origin_x = from_coords.0 + half_width;
+        let origin_y = from_coords.1 + half_height;
+        let dest_x = to_coords.0 + half_width;
+        let dest_y = to_coords.1 + half_height;
+
+        let angle = (dest_y - origin_y).atan2(dest_x - origin_x);
+        let cosine = angle.cos();
+        let sine = angle.sin();
+
+        // Offset from vertex edges
+        let offset_origin_x = origin_x + half_width * cosine;
+        let offset_origin_y = origin_y + half_height * sine;
+        let offset_dest_x = dest_x - half_width * cosine;
+        let offset_dest_y = dest_y - half_height * sine;
+
+        // Draw line
+        ctx.move_to(offset_origin_x, offset_origin_y);
+        ctx.line_to(offset_dest_x, offset_dest_y);
+        ctx.stroke()?;
+
+        // Draw arrowhead if directed
+        if dependency.is_directed {
+            let upper_angle = angle - arrow_angle;
+            let lower_angle = angle + arrow_angle;
+            let arrowhead_size = config.theme.sizes.arrowhead_size;
+
+            ctx.move_to(
+                offset_dest_x - arrowhead_size * upper_angle.cos(),
+                offset_dest_y - arrowhead_size * upper_angle.sin(),
+            );
+            ctx.line_to(offset_dest_x, offset_dest_y);
+            ctx.line_to(
+                offset_dest_x - arrowhead_size * lower_angle.cos(),
+                offset_dest_y - arrowhead_size * lower_angle.sin(),
+            );
+            ctx.stroke()?;
+        }
+    }
+
+    ctx.restore()?;
+    Ok(())
+}
+
+fn draw_groups(ctx: &cairo::Context, map: &Map, config: &Configuration) -> Result<(), RenderError> {
+    use geo::{ConcaveHull, LineString, Point};
+    use std::collections::HashMap;
+    use std::f64::consts::PI;
+
+    // Build component map (top-left corner positions)
+    let mut component_map: HashMap<String, (f64, f64)> = HashMap::new();
+    for component in &map.components {
+        let x = percent_to_pixel(component.coordinates.0, config.theme.sizes.map_width);
+        let y = percent_to_pixel(component.coordinates.1, config.theme.sizes.map_height);
+        component_map.insert(component.label.to_lowercase(), (x, y));
+    }
+
+    // Create offscreen surface for opacity handling
+    let width = (config.theme.sizes.map_width + config.theme.sizes.vertex_size) as i32;
+    let height = (config.theme.sizes.map_height + config.theme.sizes.vertex_size) as i32;
+    let offscreen = cairo::ImageSurface::create(cairo::Format::ARgb32, width, height)?;
+    let offscreen_ctx = cairo::Context::new(&offscreen)?;
+
+    // Translate to account for vertex width/height
+    offscreen_ctx.translate(
+        config.theme.sizes.vertex_size / 2.0,
+        config.theme.sizes.vertex_size / 2.0,
+    );
+
+    for (group_index, group) in map.groups.iter().enumerate() {
+        let component_coords: Vec<(f64, f64)> = group
+            .components
+            .iter()
+            .filter_map(|label| component_map.get(&label.to_lowercase()).copied())
+            .collect();
+
+        if component_coords.is_empty() {
+            continue;
+        }
+
+        let color = &config.theme.colors.groups[group_index % config.theme.colors.groups.len()];
+        let is_line = component_coords.len() == 2;
+
+        let coords = if component_coords.len() == 1 {
+            // For 1 component, create a small circle
+            let (x, y) = component_coords[0];
+            let radius = 3.0;
+            let segments = 16;
+            let mut circle_coords = Vec::new();
+            for i in 0..=segments {
+                let angle = (i as f64 / segments as f64) * 2.0 * PI;
+                circle_coords.push((x + radius * angle.cos(), y + radius * angle.sin()));
+            }
+            circle_coords
+        } else if is_line {
+            // For 2 components, simple line
+            component_coords
+        } else {
+            // For 3+ components, use concave hull
+            let points: Vec<Point> = component_coords
+                .iter()
+                .map(|&(x, y)| Point::new(x, y))
+                .collect();
+
+            let line_string: LineString = points.into();
+            let hull = line_string.concave_hull(2.0);
+            hull.exterior().coords().map(|c| (c.x, c.y)).collect()
+        };
+
+        if coords.is_empty() {
+            continue;
+        }
+
+        // Clear offscreen canvas
+        offscreen_ctx.set_operator(cairo::Operator::Clear);
+        offscreen_ctx.paint()?;
+        offscreen_ctx.set_operator(cairo::Operator::Over);
+
+        // Draw path
+        set_color(&offscreen_ctx, color);
+        offscreen_ctx.move_to(coords[0].0, coords[0].1);
+        for &(x, y) in &coords[1..] {
+            offscreen_ctx.line_to(x, y);
+        }
+
+        // For polygons (not lines), close path and fill
+        if !is_line {
+            offscreen_ctx.close_path();
+            offscreen_ctx.fill_preserve()?;
+        }
+
+        // Draw stroke with round caps and joins for smoother appearance
+        offscreen_ctx.set_line_width(config.theme.sizes.vertex_size * 1.75);
+        offscreen_ctx.set_line_cap(cairo::LineCap::Round);
+        offscreen_ctx.set_line_join(cairo::LineJoin::Round);
+        offscreen_ctx.stroke()?;
+
+        // Composite onto main context with opacity
+        ctx.save()?;
+        ctx.set_source_surface(&offscreen, 0.0, 0.0)?;
+        ctx.paint_with_alpha(config.theme.opacity.groups)?;
+        ctx.restore()?;
+    }
+
+    Ok(())
+}
+
+fn draw_vertices(
+    ctx: &cairo::Context,
+    map: &Map,
+    config: &Configuration,
+) -> Result<(), RenderError> {
+    use crate::shapes::draw_vertex;
+
+    ctx.save()?;
+    set_color(ctx, &config.theme.colors.vertex);
+
+    for component in &map.components {
+        let x = percent_to_pixel(component.coordinates.0, config.theme.sizes.map_width);
+        let y = percent_to_pixel(component.coordinates.1, config.theme.sizes.map_height);
+
+        draw_vertex(
+            ctx,
+            &component.shape,
+            x,
+            y,
+            config.theme.sizes.vertex_size,
+            config.theme.sizes.vertex_size,
+        )?;
+    }
+
+    ctx.restore()?;
+    Ok(())
+}
+
+fn draw_vertex_labels(
+    ctx: &cairo::Context,
+    map: &Map,
+    config: &Configuration,
+) -> Result<(), RenderError> {
+    ctx.save()?;
+    set_color(ctx, &config.theme.colors.label);
+    ctx.select_font_face(
+        "sans-serif",
+        cairo::FontSlant::Normal,
+        cairo::FontWeight::Normal,
+    );
+    ctx.set_font_size(config.theme.fonts.vertex_label);
+
+    for component in &map.components {
+        let (label_x, label_y) = if config.options.smart_label_positioning {
+            // Use smart label positioning to find optimal position
+            use crate::smart_positioning::calculate_optimal_label_position;
+
+            let position = calculate_optimal_label_position(
+                component,
+                map,
+                config.theme.sizes.map_width,
+                config.theme.sizes.map_height,
+                config.theme.sizes.vertex_size,
+                ctx,
+                config.theme.fonts.vertex_label,
+            )?;
+
+            // Adjust Y position for text baseline
+            (position.x, position.y + 7.0)
+        } else {
+            // Simple label positioning (to the right of vertex)
+            let x = percent_to_pixel(component.coordinates.0, config.theme.sizes.map_width);
+            let y = percent_to_pixel(component.coordinates.1, config.theme.sizes.map_height);
+            (
+                x + config.theme.sizes.vertex_size + 5.0,
+                y + config.theme.sizes.vertex_size / 2.0 + config.theme.fonts.vertex_label / 3.0,
+            )
+        };
+
+        ctx.move_to(label_x, label_y);
+        ctx.show_text(&component.label)?;
+    }
+
+    ctx.restore()?;
+    Ok(())
+}
+
+fn draw_inertias(
+    ctx: &cairo::Context,
+    map: &Map,
+    config: &Configuration,
+) -> Result<(), RenderError> {
+    use std::collections::HashMap;
+
+    // Build component map (top-left corner positions)
+    let mut component_map: HashMap<String, (f64, f64)> = HashMap::new();
+    for component in &map.components {
+        let x = percent_to_pixel(component.coordinates.0, config.theme.sizes.map_width);
+        let y = percent_to_pixel(component.coordinates.1, config.theme.sizes.map_height);
+        component_map.insert(component.label.to_lowercase(), (x, y));
+    }
+
+    ctx.save()?;
+    set_color(ctx, &config.theme.colors.inertia);
+
+    let corner_radius = 2.0;
+    let rect_width = config.theme.sizes.vertex_size / 2.0;
+    let rect_height = config.theme.sizes.vertex_size * 2.0;
+
+    for inertia in &map.inertias {
+        if let Some(&(origin_x, origin_y)) = component_map.get(&inertia.component.to_lowercase()) {
+            // Position relative to vertex top-left corner
+            let x = origin_x + 3.0 * config.theme.sizes.vertex_size;
+            let y = origin_y - (config.theme.sizes.vertex_size * 2.0) / 3.0;
+
+            // Draw rounded rectangle
+            draw_rounded_rect(ctx, x, y, rect_width, rect_height, corner_radius)?;
+            ctx.fill()?;
+        }
+    }
+
+    ctx.restore()?;
+    Ok(())
+}
+
+fn draw_rounded_rect(
+    ctx: &cairo::Context,
+    x: f64,
+    y: f64,
+    width: f64,
+    height: f64,
+    radius: f64,
+) -> Result<(), cairo::Error> {
+    let r = radius;
+    ctx.new_path();
+    ctx.arc(
+        x + r,
+        y + r,
+        r,
+        std::f64::consts::PI,
+        3.0 * std::f64::consts::PI / 2.0,
+    );
+    ctx.arc(
+        x + width - r,
+        y + r,
+        r,
+        3.0 * std::f64::consts::PI / 2.0,
+        0.0,
+    );
+    ctx.arc(
+        x + width - r,
+        y + height - r,
+        r,
+        0.0,
+        std::f64::consts::PI / 2.0,
+    );
+    ctx.arc(
+        x + r,
+        y + height - r,
+        r,
+        std::f64::consts::PI / 2.0,
+        std::f64::consts::PI,
+    );
+    ctx.close_path();
+    Ok(())
+}
+
+/// Wraps text to fit within a given width, breaking at word boundaries
+fn wrap_text(
+    ctx: &cairo::Context,
+    text: &str,
+    max_width: f64,
+) -> Result<Vec<String>, cairo::Error> {
+    let words: Vec<&str> = text.split_whitespace().collect();
+    let mut lines = Vec::new();
+    let mut current_line = String::new();
+
+    for word in words {
+        let test_line = if current_line.is_empty() {
+            word.to_string()
+        } else {
+            format!("{} {}", current_line, word)
+        };
+
+        let extents = ctx.text_extents(&test_line)?;
+
+        if extents.width() <= max_width {
+            current_line = test_line;
+        } else {
+            if !current_line.is_empty() {
+                lines.push(current_line);
+            }
+            current_line = word.to_string();
+        }
+    }
+
+    if !current_line.is_empty() {
+        lines.push(current_line);
+    }
+
+    // If no lines were created (single very long word), just use the original text
+    if lines.is_empty() {
+        lines.push(text.to_string());
+    }
+
+    Ok(lines)
+}
+
+fn draw_evolutions(
+    ctx: &cairo::Context,
+    map: &Map,
+    config: &Configuration,
+) -> Result<(), RenderError> {
+    use std::collections::HashMap;
+    use std::f64::consts::PI;
+
+    // Build component map (top-left corner positions)
+    let mut component_map: HashMap<String, (f64, f64)> = HashMap::new();
+    for component in &map.components {
+        let x = percent_to_pixel(component.coordinates.0, config.theme.sizes.map_width);
+        let y = percent_to_pixel(component.coordinates.1, config.theme.sizes.map_height);
+        component_map.insert(component.label.to_lowercase(), (x, y));
+    }
+
+    ctx.save()?;
+    set_color(ctx, &config.theme.colors.evolution);
+    ctx.set_line_width(config.theme.sizes.line_width * 2.0);
+    ctx.set_dash(&[10.0], 0.0);
+
+    for evolution in &map.evolutions {
+        if let Some(&(origin_x, origin_y)) = component_map.get(&evolution.component.to_lowercase())
+        {
+            // Calculate destination with clamping
+            let evolution_offset = percent_to_pixel(evolution.value, config.theme.sizes.map_width);
+            let dest_x = (origin_x + evolution_offset)
+                .max(0.0)
+                .min(config.theme.sizes.map_width);
+            let dest_y = origin_y;
+
+            // Determine direction
+            let multiplier = if dest_x > origin_x { 1.0 } else { -1.0 };
+
+            // Calculate offsets from top-left corner to center the line on the vertex
+            let offset_origin_x = origin_x
+                + multiplier * (config.theme.sizes.vertex_size / 2.0)
+                + config.theme.sizes.vertex_size / 2.0;
+            let offset_origin_y = origin_y + config.theme.sizes.vertex_size / 2.0;
+            let offset_dest_x = dest_x - multiplier * (config.theme.sizes.vertex_size / 2.0)
+                + config.theme.sizes.vertex_size / 2.0;
+            let offset_dest_y = dest_y + config.theme.sizes.vertex_size / 2.0;
+
+            // Draw dashed line
+            ctx.move_to(offset_origin_x, offset_origin_y);
+            ctx.line_to(offset_dest_x, offset_dest_y);
+            ctx.stroke()?;
+
+            // Draw arrowhead at destination only
+            let upper_angle = -PI / 4.0;
+            let lower_angle = PI / 4.0;
+            let arrowhead_size = config.theme.sizes.arrowhead_size;
+
+            ctx.move_to(offset_dest_x, offset_dest_y);
+            ctx.line_to(
+                offset_dest_x - multiplier * arrowhead_size * upper_angle.cos(),
+                offset_dest_y - multiplier * arrowhead_size * upper_angle.sin(),
+            );
+            ctx.stroke()?;
+
+            ctx.move_to(offset_dest_x, offset_dest_y);
+            ctx.line_to(
+                offset_dest_x - multiplier * arrowhead_size * lower_angle.cos(),
+                offset_dest_y - multiplier * arrowhead_size * lower_angle.sin(),
+            );
+            ctx.stroke()?;
+        }
+    }
+
+    ctx.restore()?;
+    Ok(())
+}
+
+fn draw_notes(ctx: &cairo::Context, map: &Map, config: &Configuration) -> Result<(), RenderError> {
+    let padding = 5.0;
+    let max_width = 400.0;
+
+    ctx.save()?;
+    ctx.select_font_face(
+        "sans-serif",
+        cairo::FontSlant::Normal,
+        cairo::FontWeight::Normal,
+    );
+    ctx.set_font_size(config.theme.fonts.note);
+
+    for note in &map.notes {
+        let x = percent_to_pixel(note.coordinates.0, config.theme.sizes.map_width);
+        let y = percent_to_pixel(note.coordinates.1, config.theme.sizes.map_height);
+
+        // Split text by newlines (handle both \\n escape and actual newlines)
+        let text = note.text.replace("\\n", "\n");
+        let lines: Vec<&str> = text.split('\n').collect();
+
+        // Calculate box dimensions
+        let mut widest_line = 0.0;
+        for line in &lines {
+            let extents = ctx.text_extents(line)?;
+            if extents.width() > widest_line {
+                widest_line = extents.width();
+            }
+        }
+
+        let box_width = f64::min(max_width, widest_line + padding * 2.0);
+        let box_height = lines.len() as f64 * config.theme.line_heights.note + padding * 2.0;
+
+        // Draw background
+        set_color(ctx, &config.theme.colors.background);
+        ctx.rectangle(x, y, box_width, box_height);
+        ctx.fill()?;
+
+        // Draw border
+        set_color(ctx, &config.theme.colors.vertex);
+        ctx.set_line_width(config.theme.sizes.line_width);
+        ctx.rectangle(x, y, box_width, box_height);
+        ctx.stroke()?;
+
+        // Draw text
+        set_color(ctx, &config.theme.colors.label);
+        for (i, line) in lines.iter().enumerate() {
+            ctx.move_to(
+                x + padding,
+                y + padding + i as f64 * config.theme.line_heights.note + config.theme.fonts.note,
+            );
+            ctx.show_text(line)?;
+        }
+    }
+
+    ctx.restore()?;
+    Ok(())
+}
+
+/// Gets the pixel positions of evolution stages
+fn get_stage_positions(map: &Map, config: &Configuration) -> [f64; 3] {
+    use wmap_parser::Stage;
+
+    let default_stages = [25.0, 50.0, 75.0];
+    let mut stages = default_stages;
+
+    // Override with map-specific stages if provided
+    for stage_data in &map.stages {
+        let index = match stage_data.stage {
+            Stage::I => 0,
+            Stage::Ii => 1,
+            Stage::Iii => 2,
+            Stage::Iv => continue, // Stage IV doesn't have a divider line
+        };
+        stages[index] = stage_data.value; // Value is already a percentage (0-100)
+    }
+
+    [
+        percent_to_pixel(stages[0], config.theme.sizes.map_width),
+        percent_to_pixel(stages[1], config.theme.sizes.map_width),
+        percent_to_pixel(stages[2], config.theme.sizes.map_width),
+    ]
+}