crossmate

ClueBar.swift (6603B)

---

 import SwiftUI
 
 private struct ClueKey: Hashable {
     let direction: Puzzle.Direction
     let number: Int
 }
 
 private struct ReplayClueTarget {
     let position: GridPosition
     let direction: Puzzle.Direction?
 }
 
 struct ClueBarSlot: View {
     @Bindable var session: PlayerSession
     let replayFrame: ReplayFrame?
 
     private var replayClueTarget: ReplayClueTarget? {
         guard let cursor = replayFrame?.cursor else { return nil }
         return ReplayClueTarget(position: cursor, direction: replayFrame?.cursorDirection)
     }
 
     var body: some View {
         ZStack(alignment: .bottom) {
             ClueBarReservation()
 
             ClueBar(session: session, replayClueTarget: replayClueTarget)
         }
     }
 }
 
 private struct ClueBarReservation: View {
     var body: some View {
         ClueBarContent(
             label: "99 Across",
             clueText: AttributedString("Clue reservation"),
             reservesClueSpace: true
         )
             .opacity(0)
             .accessibilityHidden(true)
             .allowsHitTesting(false)
     }
 }
 
 private struct ClueBarContent: View {
     let label: String
     let clueText: AttributedString
     var reservesClueSpace = false
     var currentKey: ClueKey?
     var slideEdge: Edge = .trailing
     var onPrevious: (() -> Void)?
     var onNext: (() -> Void)?
     var onClueTap: (() -> Void)?
     var onLabelTap: (() -> Void)?
 
     var body: some View {
         HStack(alignment: .clueCenter, spacing: 8) {
             ClueBarIcon(systemName: "chevron.left", action: onPrevious)
 
             VStack(alignment: .leading, spacing: 4) {
                 Text(label)
                     .font(.caption)
                     .textCase(.uppercase)
                     .foregroundStyle(.secondary)
                     .contentShape(Rectangle())
                     .highPriorityGesture(
                         TapGesture()
                             .onEnded {
                                 onLabelTap?()
                             }
                     )
                 ZStack(alignment: .leading) {
                     clueTextView
                 }
                 .alignmentGuide(.clueCenter) { d in d[VerticalAlignment.center] }
                 .frame(maxWidth: .infinity, alignment: .leading)
                 .clipped()
             }
             .contentShape(Rectangle())
             .onTapGesture {
                 onClueTap?()
             }
 
             ClueBarIcon(systemName: "chevron.right", action: onNext)
         }
         .padding(.horizontal, 8)
         .padding(.top, 12)
         .padding(.bottom, 6)
     }
 
     @ViewBuilder
     private var clueTextView: some View {
         baseClueText
             .id(currentKey)
             .transition(.push(from: slideEdge))
     }
 
     private var baseClueText: some View {
         Text(clueText)
             .font(.headline)
             .lineLimit(2, reservesSpace: reservesClueSpace)
             .multilineTextAlignment(.leading)
             .frame(maxWidth: .infinity, alignment: .leading)
     }
 }
 
 private struct ClueBarIcon: View {
     let systemName: String
     var action: (() -> Void)?
 
     var body: some View {
         if let action {
             Button(action: action) {
                 icon
             }
             .buttonStyle(.plain)
         } else {
             icon
         }
     }
 
     private var icon: some View {
         Image(systemName: systemName)
             .font(.title3.weight(.semibold))
             .frame(width: 44, height: 44)
             .contentShape(Rectangle())
     }
 }
 
 private struct ClueBar: View {
     @Bindable var session: PlayerSession
     let replayClueTarget: ReplayClueTarget?
     @Environment(PlayerPreferences.self) private var preferences
     @Environment(\.colorScheme) private var colorScheme
     @State private var slideEdge: Edge = .trailing
     @State private var isShowingClueList = false
 
     private var backgroundColor: Color {
         preferences.color.clueBarFill(dark: colorScheme == .dark)
     }
 
     var body: some View {
         let display = replayClueDisplay ?? liveClueDisplay
         let isShowingReplayClue = replayClueDisplay != nil
 
         ClueBarContent(
             label: label(for: display.clue, direction: display.direction),
             clueText: display.clue?.attributedText ?? AttributedString("—"),
             currentKey: display.currentKey,
             slideEdge: slideEdge,
             onPrevious: isShowingReplayClue ? nil : {
                 slideEdge = .leading
                 session.goToPreviousClue()
             },
             onNext: isShowingReplayClue ? nil : {
                 slideEdge = .trailing
                 session.goToNextClue()
             },
             onClueTap: isShowingReplayClue ? nil : {
                 isShowingClueList = true
             },
             onLabelTap: isShowingReplayClue ? nil : {
                 session.toggleDirection()
             }
         )
         .background(backgroundColor)
         .animation(
             isShowingReplayClue ? nil : .smooth(duration: 0.22),
             value: display.currentKey
         )
         .sheet(isPresented: $isShowingClueList) {
             ClueList(session: session)
                 .presentationDetents([.medium, .large])
                 .presentationDragIndicator(.visible)
         }
     }
 
     private var liveClueDisplay: ClueDisplay {
         let clue = session.currentClue()
         return ClueDisplay(clue: clue, direction: session.direction)
     }
 
     private var replayClueDisplay: ClueDisplay? {
         guard let replayClueTarget else { return nil }
         let position = replayClueTarget.position
         guard let direction = replayClueTarget.direction else { return nil }
         return ClueDisplay(
             clue: session.puzzle.clue(atRow: position.row, col: position.col, direction: direction),
             direction: direction
         )
     }
 
     private struct ClueDisplay {
         let clue: Puzzle.Clue?
         let direction: Puzzle.Direction
 
         var currentKey: ClueKey? {
             clue.map { ClueKey(direction: direction, number: $0.number) }
         }
     }
 
     private func label(for clue: Puzzle.Clue?, direction: Puzzle.Direction) -> String {
         let direction = direction == .across ? "Across" : "Down"
         if let clue {
             return "\(clue.number) \(direction)"
         }
         return direction
     }
 }
 
 private extension VerticalAlignment {
     enum ClueCenterID: AlignmentID {
         static func defaultValue(in d: ViewDimensions) -> CGFloat { d[VerticalAlignment.center] }
     }
     static let clueCenter = VerticalAlignment(ClueCenterID.self)
 }