blockworx/tools/

route_tool.rs

use std::collections::BTreeMap;

use blockworx_doc::geometry::Waypoint;
use blockworx_doc::id::{BlockId, PinId};
use blockworx_geom::Pos2;
use blockworx_router::{ClosedRouter, point::Point};

use crate::render::render_path_with_chamfered_corners;
use crate::theme::Style;
use crate::{
    edit::create::PathOrdinal,
    grid::{PORT_RADIUS, grid_point, px_point, snap_to_grid},
    shape::PinLocation,
    theme::Role,
    tools::{
        SelectTool,
        names::ToolName,
        new_pin::{
            NEW_PIN_ACTIVATION_RANGE, active_new_pin_target, draw_route_new_pin_targets,
            new_pin_targets,
        },
        rename_pin::{Field, RenamePin},
        route_start,
        tool::{Action, ToolTrait},
    },
    widget::{
        drawing::Drawing,
        waypoint_router::{
            FixedLegs, RouteRequest, SelfCost, TaggedPoint, route_fixed_legs, route_to_head,
        },
    },
};
use blockworx_paint::{Canvas, Cursor, Event, Interaction};
/// The in-progress corners as the router speaks them: waypoints are
/// positional, so a corner's identity is its index in the list.
fn waypoint_nodes(waypoints: &[Waypoint]) -> (Vec<PathOrdinal>, BTreeMap<PathOrdinal, Point>) {
    let positions: BTreeMap<PathOrdinal, Point> = waypoints
        .iter()
        .enumerate()
        .map(|(index, wp)| (PathOrdinal::new(index), waypoint_point(wp)))
        .collect();
    (positions.keys().copied().collect(), positions)
}

fn waypoint_point(wp: &Waypoint) -> Point {
    Point::from(wp.pos)
}

/// Route an in-progress route (`start` → each waypoint → `end`) against a freshly
/// built closed router, seeding the endpoints and waypoints so they are graph
/// nodes. Used at commit time, where the exact final geometry (and the route's own
/// occupancy) matters. The live preview instead routes against a cached router
/// (see `RouteTool::preview_route`).
fn route_in_progress(
    data: &Drawing,
    start: Pos2,
    waypoints: &[Waypoint],
    end: Pos2,
) -> Vec<TaggedPoint> {
    let mut extra: Vec<Point> = Vec::with_capacity(waypoints.len() + 2);
    extra.push(start.into());
    extra.push(end.into());
    extra.extend(waypoints.iter().map(waypoint_point));
    let mut router = data.scratch_closed_router(&extra);
    let (wp_ids, wp_positions) = waypoint_nodes(waypoints);
    RouteRequest {
        start: start.into(),
        end: end.into(),
        wp_ids: &wp_ids,
        wp_positions: &wp_positions,
        self_cost: SelfCost::Apply,
    }
    .route(&mut router)
}

#[derive(Default)]
enum RouteToolState {
    #[default]
    Idle,
    PinHeadHovered {
        anchor: PinId,
    },
    InProgress {
        start: PinId,
        waypoints: Vec<Waypoint>,
        head: Pos2,
    },
    Proposed {
        start: PinId,
        waypoints: Vec<Waypoint>,
        finish: FinishTarget,
    },
}

/// Where an in-progress route proposes to end. An existing pin resolves to its
/// anchor directly; a new-pin target names the block and slot where the pin will
/// be materialized at commit time, along with its prospective connection point.
#[derive(Clone, Copy)]
enum FinishTarget {
    Anchor(PinId),
    NewPin {
        block: BlockId,
        loc: PinLocation,
        center: Pos2,
    },
}

/// The in-progress route a preview frame lays out: where it starts, the
/// waypoints committed so far, and the cursor it currently reaches to.
struct PreviewRequest<'a> {
    start: PinId,
    start_pos: Pos2,
    waypoints: &'a [Waypoint],
    end: Pos2,
}

/// Everything cached across frames of one route gesture while only the cursor
/// moves. The graph (obstacles + existing routes + `start` + waypoints) and the
/// fixed `start → … → last waypoint` legs are both invariant until a waypoint is
/// added, so both are computed once. Keyed by `start` + waypoint count.
struct PreviewCache {
    start: PinId,
    waypoint_count: usize,
    router: ClosedRouter,
    fixed: FixedLegs,
}

#[derive(Default)]
pub struct RouteTool {
    state: RouteToolState,
    preview_path: Vec<TaggedPoint>,
    /// Cached router + fixed legs for the live preview; rebuilt only when a
    /// waypoint is added or a new route starts, and dropped when the gesture ends
    /// (which also covers commit changing the set of existing routes). Boxed to
    /// keep it off the `Tool` enum's stack footprint — it is the widest thing a
    /// tool owns, and only the route tool ever has one.
    preview_cache: Option<Box<PreviewCache>>,
    /// When set, completing or cancelling the route returns to the select tool
    /// (the route was started from a select-tool hover target) rather than
    /// staying in the route tool ready for the next route.
    return_to_select: bool,
    /// When set, the route was started by pulling a fresh port out of a block's
    /// "+" target, so committing the wire drops into editing that start port's
    /// name. Cleared if the gesture is abandoned.
    edit_start_on_commit: bool,
    /// The start port to open for name editing, stashed by a successful commit
    /// when [`Self::edit_start_on_commit`] is set and consumed by `widget`.
    pending_name_edit: Option<PinId>,
}

impl ToolTrait for RouteTool {
    fn name(&self) -> ToolName {
        ToolName::Route
    }

    fn widget<C: Canvas>(
        &mut self,
        data: &mut Drawing,
        interaction: &Interaction,
        painter: &mut Style<'_, C>,
    ) -> Option<Action> {
        // Take ownership of the current state, leaving Idle in place.
        // This avoids borrow-checker issues when transitioning states.
        let state = std::mem::take(&mut self.state);

        crate::widget::display::widget(data, interaction, painter);
        painter.set_cursor(Cursor::Crosshair);

        let was_routing = matches!(
            state,
            RouteToolState::InProgress { .. } | RouteToolState::Proposed { .. }
        );
        // Esc or Backspace cancels an in-progress route, discarding it.
        let cancelled = was_routing && (interaction.escape_pressed || interaction.delete_pressed);

        self.state = if cancelled {
            self.preview_path.clear();
            // The fresh-port gesture was abandoned, so don't rename on a later commit.
            self.edit_start_on_commit = false;
            RouteToolState::Idle
        } else {
            match state {
                RouteToolState::Idle => match interaction.event {
                    Some(Event::DragStarted { pos } | Event::Clicked { pos }) => {
                        if let Some(anchor) = data.anchor_at_pos(pos) {
                            RouteToolState::InProgress {
                                start: anchor,
                                waypoints: Vec::new(),
                                head: pos,
                            }
                        } else {
                            RouteToolState::Idle
                        }
                    }
                    Some(Event::HoverAt(pos)) => {
                        if let Some(anchor) = data.anchor_at_pos(pos) {
                            RouteToolState::PinHeadHovered { anchor }
                        } else {
                            RouteToolState::Idle
                        }
                    }
                    _ => RouteToolState::Idle,
                },

                RouteToolState::PinHeadHovered { anchor } => match interaction.event {
                    Some(Event::DragStarted { pos } | Event::Clicked { pos }) => {
                        RouteToolState::InProgress {
                            start: anchor,
                            waypoints: Vec::new(),
                            head: pos,
                        }
                    }
                    Some(Event::HoverAt(pos)) => {
                        if let Some(new_anchor) = data.anchor_at_pos(pos) {
                            RouteToolState::PinHeadHovered { anchor: new_anchor }
                        } else {
                            RouteToolState::Idle
                        }
                    }
                    _ => RouteToolState::PinHeadHovered { anchor },
                },

                RouteToolState::InProgress {
                    start,
                    mut waypoints,
                    mut head,
                } => match interaction.event {
                    Some(Event::Clicked { pos }) => {
                        waypoints.push(Waypoint {
                            pos: grid_point(pos),
                            locked: true,
                        });
                        RouteToolState::InProgress {
                            start,
                            waypoints,
                            head,
                        }
                    }
                    // A drag away from the start anchor previews the route to the
                    // cursor, proposing a connection once it reaches another anchor or
                    // an armed new-pin target.
                    Some(Event::HoverAt(pos) | Event::Dragging { pos, .. }) => {
                        if let Some(finish) = Self::finish_at(data, start, pos) {
                            RouteToolState::Proposed {
                                start,
                                waypoints,
                                finish,
                            }
                        } else {
                            head = pos;
                            RouteToolState::InProgress {
                                start,
                                waypoints,
                                head,
                            }
                        }
                    }
                    // Releasing on a second anchor (or armed new-pin target) completes
                    // the route; releasing anywhere else leaves the operation in
                    // progress, exactly as a click on the start anchor would.
                    Some(Event::DragStopped { pos }) => {
                        if let Some(finish) = Self::finish_at(data, start, pos) {
                            self.commit(data, start, finish, waypoints)
                        } else {
                            head = pos;
                            RouteToolState::InProgress {
                                start,
                                waypoints,
                                head,
                            }
                        }
                    }
                    _ => RouteToolState::InProgress {
                        start,
                        waypoints,
                        head,
                    },
                },

                RouteToolState::Proposed {
                    start,
                    waypoints,
                    mut finish,
                } => match interaction.event {
                    Some(Event::Clicked { .. }) => self.commit(data, start, finish, waypoints),
                    // Releasing on the proposed target completes the route; releasing
                    // off it continues the operation from the start anchor.
                    Some(Event::DragStopped { pos }) => match Self::finish_at(data, start, pos) {
                        Some(finish) => self.commit(data, start, finish, waypoints),
                        None => RouteToolState::InProgress {
                            start,
                            waypoints,
                            head: pos,
                        },
                    },
                    Some(Event::HoverAt(pos) | Event::Dragging { pos, .. }) => {
                        match Self::finish_at(data, start, pos) {
                            Some(new_finish) => {
                                finish = new_finish;
                                RouteToolState::Proposed {
                                    start,
                                    waypoints,
                                    finish,
                                }
                            }
                            None => RouteToolState::InProgress {
                                start,
                                waypoints,
                                head: pos,
                            },
                        }
                    }
                    _ => RouteToolState::Proposed {
                        start,
                        waypoints,
                        finish,
                    },
                },
            }
        };

        self.update_preview(data);
        self.render(data, painter);
        // A committed route is inserted after this frame's canvas was already
        // drawn (display runs at the top of `widget`), so without a nudge nothing
        // repaints to show it until the next stray input. Request one frame so the
        // new route — and any pin it created — appears immediately.
        let committed = was_routing && !cancelled && matches!(self.state, RouteToolState::Idle);
        if committed {
            painter.request_repaint();
        }
        // A route pulled from a fresh port opens that port's name for editing once
        // the wire commits, so the new port can be labelled straight away.
        if let Some(anchor) = self.pending_name_edit.take()
            && let Some(tool) = RenamePin::new_with_anchor(data, anchor, Field::Name)
        {
            return Some(Action::SwitchTool(tool.into()));
        }
        // A route started from the select tool returns there once it lands in
        // Idle — whether by completing (commit) or cancelling.
        if self.return_to_select && was_routing && matches!(self.state, RouteToolState::Idle) {
            return Some(Action::SwitchTool(SelectTool.into()));
        }
        None
    }
}

impl RouteTool {
    /// Start routing immediately from `start`, with the route head at `head`.
    /// Lets another tool chain "add a pin and route from it" in one drag: the
    /// caller hands off mid-drag and the existing [`RouteToolState::InProgress`]
    /// handling carries the same gesture to a connecting anchor.
    pub fn routing_from(start: PinId, head: Pos2) -> Self {
        Self {
            state: RouteToolState::InProgress {
                start,
                waypoints: Vec::new(),
                head,
            },
            preview_path: Vec::new(),
            preview_cache: None,
            return_to_select: false,
            edit_start_on_commit: false,
            pending_name_edit: None,
        }
    }

    /// Like [`Self::routing_from`], but the route was started by pulling a fresh
    /// port out of a block's "+" target, so committing the wire opens that port's
    /// name for editing.
    pub fn routing_from_new_pin(start: PinId, head: Pos2) -> Self {
        Self {
            edit_start_on_commit: true,
            ..Self::routing_from(start, head)
        }
    }

    /// Like [`Self::routing_from`], but completing or cancelling the route returns
    /// to the select tool. Used when a route is started from a select-tool hover
    /// target.
    pub fn routing_from_select(start: PinId, head: Pos2) -> Self {
        Self {
            return_to_select: true,
            ..Self::routing_from(start, head)
        }
    }

    /// Build and add the route from `start` to `finish` through `waypoints` and
    /// return to Idle. A [`FinishTarget::NewPin`] finish materializes its pin
    /// first, in this same frame, so the pin and route collapse into one undo
    /// step (state is snapshotted once per frame). A degenerate (zero-length)
    /// route is rejected, leaving the proposal in place — and, importantly, no
    /// pin is created in that case.
    fn commit(
        &mut self,
        data: &mut Drawing,
        start: PinId,
        finish: FinishTarget,
        waypoints: Vec<Waypoint>,
    ) -> RouteToolState {
        let Some(start_pos) = data.anchor(start) else {
            return RouteToolState::Proposed {
                start,
                waypoints,
                finish,
            };
        };
        let Some(end_pos) = Self::finish_pos(data, &finish) else {
            return RouteToolState::Proposed {
                start,
                waypoints,
                finish,
            };
        };
        if start_pos == end_pos {
            return RouteToolState::Proposed {
                start,
                waypoints,
                finish,
            };
        }
        // Only now resolve the finish — a destination the wire drew onto a free
        // slot stamps its pin in the same commit as the wire, so a rejected
        // (degenerate) route never leaves an orphan pin.
        let destination = match finish {
            FinishTarget::Anchor(anchor) => crate::edit::create::RouteEnd::Pin(anchor),
            FinishTarget::NewPin { block, loc, .. } => {
                // A stale target can still name a block that has since been
                // locked, and stamping a pin on one is a material edit — so
                // the scope has to hand out the proof before the wire can
                // carry a fresh pin at all.
                let Some(owner) = data.unlocked_scope(block) else {
                    return RouteToolState::Proposed {
                        start,
                        waypoints,
                        finish,
                    };
                };
                crate::edit::create::RouteEnd::Fresh(crate::edit::create::NewPin {
                    id: data.mint(),
                    owner,
                    slot: blockworx_doc::geometry::PinSlot {
                        side: loc.side,
                        offset: crate::grid::pin_slot(loc.offset),
                    },
                })
            }
        };
        let path = route_in_progress(
            data,
            snap_to_grid(start_pos),
            &waypoints,
            snap_to_grid(end_pos),
        );
        // The wire is stored as its corner list, so the solved polyline is
        // promoted before it lands — the "every corner is a waypoint"
        // invariant holds from the moment the route exists.
        let mut geometry = crate::widget::auto_route::geometry_from_points(&path);
        let corners =
            crate::widget::materialize::promote_corners_to_waypoints(&waypoints, &mut geometry);
        data.add_route(start, destination, corners);
        self.preview_path.clear();
        // A route pulled from a fresh port drops into editing that port's name
        // once the wire lands (see `widget`).
        if self.edit_start_on_commit {
            self.pending_name_edit = Some(start);
        }
        RouteToolState::Idle
    }

    /// Resolve a finish target's world position. An existing anchor resolves
    /// through `data`; a new-pin target reports the slot's prospective connection
    /// point directly (the pin doesn't exist yet).
    fn finish_pos(data: &Drawing, finish: &FinishTarget) -> Option<Pos2> {
        match finish {
            FinishTarget::Anchor(anchor) => data.anchor(*anchor),
            FinishTarget::NewPin { center, .. } => Some(*center),
        }
    }

    /// Resolve the cursor at `pos` to a finish target during routing: an existing
    /// anchor (other than `start`) takes priority; failing that, an armed new-pin
    /// target if the cursor is close enough to one.
    fn finish_at(data: &Drawing, start: PinId, pos: Pos2) -> Option<FinishTarget> {
        match data.anchor_at_pos(pos) {
            Some(anchor) if anchor != start => Some(FinishTarget::Anchor(anchor)),
            Some(_) => None,
            None => Self::new_pin_target_at(data, pos),
        }
    }

    /// The current-level block nearest `pos` with a free pin slot within
    /// `NEW_PIN_ACTIVATION_RANGE`, paired with its new-pin targets. Only this one
    /// block ever shows markers, so the cursor is never crowded by several blocks.
    fn nearest_block_targets(
        data: &Drawing,
        pos: Pos2,
    ) -> Option<(BlockId, Vec<(PinLocation, Pos2)>)> {
        data.current_blocks()
            // A locked block keeps its pin interface frozen: offer no new-pin
            // targets, so the route never proposes creating a pin on it.
            .filter(|(_, block)| !block.locked)
            .filter_map(|(rid, _)| {
                let targets = new_pin_targets(&data.block_shape(rid)?);
                let nearest = targets
                    .iter()
                    .map(|(_, p)| p.distance(pos))
                    .min_by(f32::total_cmp)?;
                (nearest < NEW_PIN_ACTIVATION_RANGE.get()).then_some((rid, targets, nearest))
            })
            .min_by(|a, b| a.2.total_cmp(&b.2))
            .map(|(rid, targets, _)| (rid, targets))
    }

    /// An armed new-pin target at `pos`: the nearest block's nearest free slot,
    /// within the widest grab its neighbours leave it — the same one the
    /// resize tool commits on, so the two tools cannot disagree about where
    /// the affordance is (R34).
    fn new_pin_target_at(data: &Drawing, pos: Pos2) -> Option<FinishTarget> {
        let (block, targets) = Self::nearest_block_targets(data, pos)?;
        let idx = active_new_pin_target(&targets, pos)?;
        let (loc, center) = targets[idx];
        (center.distance(pos) < crate::tools::new_pin::new_pin_grab().get())
            .then_some(FinishTarget::NewPin { block, loc, center })
    }

    fn update_preview(&mut self, data: &mut Drawing) {
        // Pull the routing request out as owned data first, so the `self.state`
        // borrow ends before `preview_route` mutably borrows `self` (the cache).
        // Only InProgress/Proposed route; idle/hover frames do no routing.
        let req: Option<(PinId, Vec<Waypoint>, Pos2)> = match &self.state {
            RouteToolState::InProgress {
                start,
                waypoints,
                head,
            } => Some((*start, waypoints.clone(), *head)),
            RouteToolState::Proposed {
                start,
                waypoints,
                finish,
            } => Self::finish_pos(data, finish).map(|end| (*start, waypoints.clone(), end)),
            _ => None,
        };
        self.preview_path = if let Some((start, waypoints, end)) = req {
            if let Some(start_pos) = data.anchor(start) {
                self.preview_route(
                    data,
                    &PreviewRequest {
                        start,
                        start_pos: snap_to_grid(start_pos),
                        waypoints: &waypoints,
                        end: snap_to_grid(end),
                    },
                )
            } else {
                self.preview_cache = None;
                Vec::new()
            }
        } else {
            // Gesture ended (idle/hover) — drop the cache so a new route (or a
            // route drawn after this one commits) rebuilds against fresh state.
            self.preview_cache = None;
            Vec::new()
        };
    }

    /// Route the in-progress route `start → waypoints → end` for the live preview,
    /// reusing the cached router. `start_pos`/`end` are grid-snapped. The router is
    /// (re)built only when its fixed inputs change — a different `start` (new route)
    /// or a different waypoint count (a waypoint was added); the moving cursor
    /// (`end`) does not change the graph and is routed via the existing L-path
    /// fallback. Routes read-only (`SelfCost::Skip` semantics) so the cache never
    /// accumulates the in-progress route's own occupancy between frames.
    fn preview_route(&mut self, data: &Drawing, gesture: &PreviewRequest<'_>) -> Vec<TaggedPoint> {
        let PreviewRequest {
            start,
            start_pos,
            waypoints,
            end,
        } = *gesture;
        let stale = match &self.preview_cache {
            Some(c) => c.start != start || c.waypoint_count != waypoints.len(),
            None => true,
        };
        if stale {
            // Seed the fixed part of the in-progress route (start + waypoints) but
            // NOT the moving head. Existing routes' occupancy is baked in by
            // `scratch_closed_router`, so the preview still avoids existing wires.
            let mut seeds: Vec<Point> = Vec::with_capacity(waypoints.len() + 1);
            seeds.push(start_pos.into());
            seeds.extend(waypoints.iter().map(waypoint_point));
            let mut router = data.scratch_closed_router(&seeds);
            let (wp_ids, wp_positions) = waypoint_nodes(waypoints);
            // Route the fixed start→…→last-waypoint legs once; only the head leg
            // is recomputed per frame below.
            let fixed = route_fixed_legs(&mut router, &wp_positions, start_pos.into(), &wp_ids);
            self.preview_cache = Some(Box::new(PreviewCache {
                start,
                waypoint_count: waypoints.len(),
                router,
                fixed,
            }));
        }
        let Some(cache) = self.preview_cache.as_mut() else {
            return Vec::new();
        };
        route_to_head(&mut cache.router, &cache.fixed, end.into())
    }

    /// While a route is in progress, surface the nearest block's new-pin targets
    /// so the route can terminate on a not-yet-existent pin.
    fn draw_new_pin_markers<C: Canvas>(data: &Drawing, painter: &mut Style<'_, C>) {
        let pointer = Self::world_pointer(painter);
        let Some(pos) = pointer else { return };
        if let Some((rid, targets)) = Self::nearest_block_targets(data, pos) {
            draw_route_new_pin_targets(rid, &targets, pointer, painter);
        }
    }

    fn render<C: Canvas>(&self, data: &Drawing, painter: &mut Style<'_, C>) {
        if matches!(
            self.state,
            RouteToolState::InProgress { .. } | RouteToolState::Proposed { .. }
        ) {
            Self::draw_new_pin_markers(data, painter);
        }
        match &self.state {
            // Pre-routing: show the same animated anchor target as the select tool.
            RouteToolState::Idle | RouteToolState::PinHeadHovered { .. } => {
                Self::draw_hover_anchor_target(data, painter);
            }
            RouteToolState::InProgress {
                start, waypoints, ..
            } => {
                let pts: Vec<Pos2> = self.preview_path.iter().map(|p| p.pos.into()).collect();
                render_path_with_chamfered_corners(&pts)
                    .render(painter, (0.5, Role::RouteInProgress));
                for wp in waypoints {
                    painter.circle_filled(px_point(wp.pos), PORT_RADIUS, Role::RouteInProgress);
                }
                Self::draw_end_target(data, *start, painter);
            }
            RouteToolState::Proposed {
                start, waypoints, ..
            } => {
                let pts: Vec<Pos2> = self.preview_path.iter().map(|p| p.pos.into()).collect();
                render_path_with_chamfered_corners(&pts)
                    .render(painter, (1.5, Role::RouteInProgress));
                // Mark where the route started; the end is shown by the grow-out
                // target below (for an existing anchor) or the new-pin marker.
                if let Some(pos) = data.anchor(*start) {
                    painter.circle(
                        pos,
                        PORT_RADIUS,
                        Role::RouteProposedEndpoint,
                        (0.5, Role::RouteProposedEndpoint),
                    );
                }
                for wp in waypoints {
                    painter.circle_filled(px_point(wp.pos), PORT_RADIUS, Role::RouteInProgress);
                }
                Self::draw_end_target(data, *start, painter);
            }
        }
    }

    /// Grow the green route-end target on the anchor nearest the cursor (other than
    /// `start`), mirroring the select tool's start affordance.
    fn draw_end_target<C: Canvas>(data: &Drawing, start: PinId, painter: &mut Style<'_, C>) {
        let Some(pointer) = Self::world_pointer(painter) else {
            return;
        };
        route_start::draw_nearest_anchor_target(data, pointer, Some(start), painter);
    }

    /// Before a route starts, show the same animated anchor target the select tool's
    /// route-start does, so hovering the route tool over a pin reads identically.
    fn draw_hover_anchor_target<C: Canvas>(data: &Drawing, painter: &mut Style<'_, C>) {
        let Some(pointer) = Self::world_pointer(painter) else {
            return;
        };
        route_start::draw_nearest_anchor_target(data, pointer, None, painter);
    }

    fn world_pointer<C: Canvas>(painter: &Style<'_, C>) -> Option<Pos2> {
        // Through the painter's pointer seam, so a scripted session's hover
        // affordances follow the demo cursor, not the user's mouse.
        painter.pointer_world()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::path::Scope;
    use crate::widget::test_fixtures::{self as fx, Scene};
    use blockworx_doc::fixtures::block_id;
    use blockworx_geom::{Rect, pos2};

    #[test]
    fn no_new_pin_targets_offered_on_a_locked_block() {
        let rid = block_id(1);
        let mut scene = Scene::new(vec![fx::block_in(
            1,
            Scope::Root,
            Rect::from_min_max(pos2(0.0, 0.0), pos2(300.0, 300.0)),
        )]);

        // A free slot's marker sits one grid cell off the block edge; aim the
        // cursor right at it so the unlocked block does offer it.
        let near = {
            let drawing = scene.drawing();
            let targets = new_pin_targets(&drawing.block_shape(rid).expect("the block"));
            targets[0].1
        };

        {
            let drawing = scene.drawing();
            assert!(
                RouteTool::nearest_block_targets(&drawing, near).is_some(),
                "an unlocked block offers new-pin targets"
            );
        }

        scene.apply(vec![fx::locked(1)]);
        let drawing = scene.drawing();
        assert!(
            RouteTool::nearest_block_targets(&drawing, near).is_none(),
            "a locked block offers no new-pin targets"
        );
    }
}