如何制作一个“粘性” CircleView 并使其附着在 SwiftUI 中另一个视图的边缘？

是否可以检测当前哪个视图位于 DragGesture 的位置下？答案中显示的技术可用于检测形状何时位于拖动点下（这是我的答案）。这GeometryReader在形状的背景中使用了，即使您有多层视图，它也应该有效。

为了找到形状边缘上最接近拖动点的点，我建议采用以下方法：

• 使用另一个答案中描述的点内框架技术确定拖动点是否靠近形状。
• 如果拖动点靠近形状，则创建两条路径：
  1. 表示形状轮廓的路径。
  2. 一条由从形状中间穿过拖动点然后超越的线组成的路径。
• 使用该Path函数lineIntersection(_:eoFill:)查找线与形状的交点。
• 交点的最后一个点将是沿着形状边缘的点。

您之前使用 包裹每个点GeometryReader。AGeometryReader很贪婪，会占用所有可用空间，因此这会使每个点的大小膨胀到父视图的完整大小。我建议不要这样做，而是使用.onGeometryChange来测量每个点的位置。

以下是更新后的示例，以显示其工作原理。它包括第二个点，因此也可以测试这些点的独立性。

import SwiftUI

struct ContentView: View {
    @State private var dragLocation: CGPoint?
    @State private var contactPoint: CGPoint?
    @State private var nearestNodeId: Int?
    @State private var previousNodeId: Int?
    
    var body: some View {
        ZStack {
            ForEach(1...5, id: \.self) { i in
                NodeView()
                    .background {
                        SplineContactDetector(nodeId: i,
                                              shape:  .rect(cornerRadius: 10),
                                              dragLocation: $dragLocation,
                                              contactPoint: $contactPoint,
                                              nearestNodeId: $nearestNodeId,
                                              previousNodeId: $previousNodeId
                        )
                    }
                    .offset(x:0, y: CGFloat(i) * 100 - 400)
            }
            
            //foreach Points
            BezierPoint(dragLocation: $dragLocation, contactPoint: contactPoint)
            BezierPoint(dragLocation: $dragLocation, contactPoint: contactPoint)
                .offset(x:0, y:100)
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .background(Color(red: 0.99, green: 0.94, blue: 0.76))
        .onChange(of: dragLocation) { _, newVal in
            if newVal == nil {
                contactPoint = nil
                nearestNodeId = nil
                previousNodeId = nil
            }
        }
    }
}

/// ///////////////////
/// Basic Views
/// /////////////////

struct BezierPoint: View {
    @Binding var dragLocation: CGPoint?
    let contactPoint: CGPoint?
    
    @State private var dragOffset: CGSize?
    @State private var currentOffset = CGSize.zero
    @State private var defaultFrame: CGRect?
    let pointsSize: CGFloat = 15
    
    private var offsetForContactPoint: CGSize? {
        if let contactPoint, let defaultFrame {
            CGSize(
                width: contactPoint.x - defaultFrame.midX,
                height: contactPoint.y - defaultFrame.midY
            )
        } else {
            nil
        }
    }
    
    private var offset: CGSize {
        let result: CGSize
        if let dragOffset {
            if let offsetForContactPoint {
                result = offsetForContactPoint
            } else {
                result = CGSize(
                    width: currentOffset.width + dragOffset.width,
                    height: currentOffset.height + dragOffset.height
                )
            }
        } else {
            result = currentOffset
        }
        return result
    }
    
    var body: some View {
        Circle()
            .fill(.blue)
            .stroke(.primary, lineWidth: 2)
            .frame(width: pointsSize, height: pointsSize)
            .offset(offset)
            .gesture(
                DragGesture(minimumDistance: 1, coordinateSpace: .global)
                    .onChanged { value in
                        dragOffset = value.translation
                        dragLocation = value.location
                    }
                    .onEnded { value in
                        if let offsetForContactPoint {
                            currentOffset = offsetForContactPoint
                        }
                        dragOffset = nil
                        dragLocation = nil
                    }
            )
            .onGeometryChange(for: CGRect.self) { proxy in
                proxy.frame(in: .global)
            } action: { frame in
                defaultFrame = frame
            }
    }
}

struct NodeView : View {
    var body: some View {
        Text("Business")
            .multilineTextAlignment(.center)
            .foregroundStyle(.red)
            .shadow(color: .black, radius: 2 )
            .frame(minHeight: 40)
            .padding( EdgeInsets(horizontal: 20, vertical: 14) )
            .background {
                // ANY Shape can be here
                RoundedRectangle(cornerRadius: 10)
            }
    }
}

/// ///////////////////
/// Helpers
/// /////////////////

struct SplineContactDetector<S: Shape> : View {
    let nodeId: Int
    let shape: S
    
    @Binding var dragLocation: CGPoint?
    @Binding var contactPoint: CGPoint?
    @Binding var nearestNodeId: Int?
    @Binding var previousNodeId: Int?
    
    private let proximityMargin: CGFloat = 10
    
    var body: some View {
        GeometryReader { proxy in
            let frame = proxy.frame(in: .global)
            let proximity = proximity(nodeId: nodeId, frame: frame, shape: shape)
            
            Color.clear
                .onChange(of: proximity) { _, newVal in
                    if newVal.isNearby {
                        if nearestNodeId != nodeId {
                            nearestNodeId = nodeId
                        }
                    } else if nearestNodeId == nodeId {
                        previousNodeId = nodeId
                        nearestNodeId = nil
                    }
                    if let nearestPoint = newVal.nearestPoint {
                        contactPoint = nearestPoint
                    }
                }
        }
    }
        
    private func proximity(nodeId: Int, frame: CGRect, shape: S) -> ProximityInfo {
        let result: ProximityInfo
        if let dragLocation {
            let isNearby = frame
                .insetBy(dx: -proximityMargin, dy: -proximityMargin)
                .contains(dragLocation)
            if isNearby || (nearestNodeId == nil && previousNodeId == nodeId) {
                let shapePath = shape.path(in: frame)
                let joiningLine = Path { path in
                    path.move(to: CGPoint(x: frame.midX, y: frame.midY))
                    let dx = dragLocation.x - frame.midX
                    let dy = dragLocation.y - frame.midY
                    path.addLine(to: CGPoint(x: dx * 1000, y: dy * 1000))
                }
                let intersection = joiningLine.lineIntersection(shapePath)
                result = ProximityInfo(isNearby: isNearby, nearestPoint: intersection.currentPoint)
            } else {
                result = ProximityInfo(isNearby: false, nearestPoint: nil)
            }
        } else {
            result = ProximityInfo(isNearby: false, nearestPoint: nil)
        }
        return result
    }
    
    private struct ProximityInfo: Equatable {
        let isNearby: Bool
        let nearestPoint: CGPoint?
    }
}