crossmate

CellView.swift (11394B)

---

 import SwiftUI
 
 struct CellView: View, Equatable {
     let cell: Puzzle.Cell
     let entry: String
     let mark: CellMark
     /// Passive cross-reference texture for this cell, or `nil` if the cell
     /// belongs to no cross-referenced clue. Each group in the puzzle is
     /// assigned a distinct pattern so separate links read differently.
     var crossRefPattern: CrossRefPattern? = nil
     /// This cell's grid position and the grid's inter-cell spacing. Passed
     /// through to the cross-reference texture so its line family is phased
     /// to a grid-wide lattice and stays continuous across cell borders.
     var gridRow: Int = 0
     var gridCol: Int = 0
     var gridSpacing: CGFloat = 1
     var authorTint: Color? = nil
 
     nonisolated static func == (lhs: CellView, rhs: CellView) -> Bool {
         lhs.cell == rhs.cell
             && lhs.entry == rhs.entry
             && lhs.mark == rhs.mark
             && lhs.crossRefPattern == rhs.crossRefPattern
             && lhs.gridRow == rhs.gridRow
             && lhs.gridCol == rhs.gridCol
             && lhs.authorTint == rhs.authorTint
     }
 
     var body: some View {
         ZStack(alignment: .topLeading) {
             background
             if !cell.isBlock {
                 // Passive cross-reference texture. Sits above the
                 // background tints (so it survives selection/author
                 // colour) but below the letter and corner markers so it
                 // never fights legibility.
                 if let crossRefPattern {
                     CrossRefPatternView(
                         pattern: crossRefPattern,
                         row: gridRow,
                         col: gridCol,
                         spacing: gridSpacing
                     )
                 }
                 if cell.special == .circled {
                     Circle()
                         .stroke(Color.black.opacity(0.55), lineWidth: 1)
                         .padding(1.5)
                 }
                 Text(entry)
                     .font(.system(size: 34, weight: .semibold, design: .rounded))
                     .foregroundStyle(entryStyle)
                     .lineLimit(1)
                     .minimumScaleFactor(0.1)
                     .allowsTightening(true)
                     .padding(.horizontal, 2)
                     .frame(maxWidth: .infinity, maxHeight: .infinity)
                 if let triangleColor = cornerTriangleColor {
                     CornerTriangle()
                         .fill(triangleColor)
                 }
             }
         }
         .frame(maxWidth: .infinity, maxHeight: .infinity)
         .contentShape(Rectangle())
     }
 
     /// Foreground style for the main entry letter. The cell fill is always
     /// white regardless of system appearance, so the letter ink is always
     /// black — it must not follow Dark Mode or it would vanish against the
     /// white cell. Pencil entries render as a lighter black; everything else
     /// — including revealed and checkedWrong cells — uses solid black. Reveal/
     /// wrong state is shown purely via the corner triangle, not by recolouring
     /// the letter.
     private var entryStyle: AnyShapeStyle {
         switch mark {
         case .pencil:
             return AnyShapeStyle(Color.black.opacity(0.5))
         case .none, .pen, .revealed:
             return AnyShapeStyle(Color.black)
         }
     }
 
     /// Fill colour for the top-right corner triangle: yellow for revealed
     /// cells, red for checkedWrong, nothing otherwise. Revealed and
     /// checkedWrong are mutually exclusive (a revealed cell can't be wrong),
     /// so the order of the checks doesn't matter.
     private var cornerTriangleColor: Color? {
         if mark.isRevealed { return .yellow }
         if mark.isCheckedWrong { return .red }
         return nil
     }
 
     // Drawn over a clear base: the white cell fill, the peer cursor tints, and
     // the local cursor's selection/highlight are all rendered behind the grid
     // (`GridBackdrop`, `RemoteCursorTints`, `LocalCursorTints`), so they show
     // through wherever this cell draws nothing. Blocks stay fully clear, letting
     // the grid's black show through.
     @ViewBuilder
     private var background: some View {
         if !cell.isBlock {
             ZStack {
                 if cell.special == .shaded {
                     Color.black.opacity(0.22)
                 }
                 // Faint background tint identifying who entered this letter in a
                 // shared game. The cursor fills it composites over are drawn
                 // behind the grid (see `LocalCursorTints`/`RemoteCursorTints`).
                 if let authorTint {
                     authorTint.opacity(PlayerColor.authorTintOpacity)
                 }
             }
         }
     }
 }
 
 /// The ordered palette of passive cross-reference textures. A puzzle can
 /// have several independent cross-reference groups; each is assigned the
 /// next pattern in this sequence (wrapping if there are more groups than
 /// patterns) so distinct links read differently at a glance. Monochrome
 /// by design — the texture layers over any cursor/author colour without
 /// competing with the app's colour-coded state.
 enum CrossRefPattern: CaseIterable, Sendable {
     case diagonalDown
     case diagonalUp
     case crosshatch
     case horizontal
     case vertical
 }
 
 /// Renders one `CrossRefPattern` filling the cell. Diagonal/line patterns
 /// are clipped to the cell bounds; the whole overlay is non-interactive.
 private struct CrossRefPatternView: View {
     let pattern: CrossRefPattern
     /// Grid position and inter-cell spacing, forwarded to `CrossRefLines`
     /// so the hatching is phased to a grid-wide lattice.
     let row: Int
     let col: Int
     let spacing: CGFloat
 
     /// Neutral ink that reads on white and over the (lightly tinted)
     /// selection/author fills alike. Tunable while we evaluate the look.
     private let ink = Color.black.opacity(0.20)
     private let lineWidth: CGFloat = 1
 
     private func lines(_ slope: CrossRefLines.Slope) -> CrossRefLines {
         CrossRefLines(slope: slope, row: row, col: col, spacing: spacing)
     }
 
     var body: some View {
         Group {
             switch pattern {
             case .diagonalDown:
                 lines(.down).stroke(ink, lineWidth: lineWidth)
             case .diagonalUp:
                 lines(.up).stroke(ink, lineWidth: lineWidth)
             case .crosshatch:
                 ZStack {
                     lines(.down).stroke(ink, lineWidth: lineWidth)
                     lines(.up).stroke(ink, lineWidth: lineWidth)
                 }
             case .horizontal:
                 lines(.horizontal).stroke(ink, lineWidth: lineWidth)
             case .vertical:
                 lines(.vertical).stroke(ink, lineWidth: lineWidth)
             }
         }
         .frame(maxWidth: .infinity, maxHeight: .infinity)
         .clipped()
         .allowsHitTesting(false)
     }
 }
 
 /// Parallel lines across the cell at one of four orientations. The line
 /// family is anchored to a grid-wide lattice derived from the cell's
 /// position rather than its own origin, so adjacent cells draw the same
 /// family and the hatching meets exactly at every border. Runs are
 /// generated past the edges and clipped by the caller.
 private struct CrossRefLines: Shape {
     enum Slope { case down, up, horizontal, vertical }
     var slope: Slope
     /// This cell's grid position and the grid's inter-cell spacing. The
     /// lattice phase is computed from these so every cell, at whatever
     /// size the layout currently gives it, lands on the same global
     /// family of lines.
     var row: Int
     var col: Int
     var spacing: CGFloat
     var spacingFraction: CGFloat = 0.24
 
     func path(in rect: CGRect) -> Path {
         var path = Path()
         let side = min(rect.width, rect.height)
         let step = max(2, side * spacingFraction)
         // Cells are square and uniformly pitched, so one pitch value
         // covers both axes. Computed from the live rect, so it tracks
         // any change in cell size automatically.
         let pitch = side + spacing
         let gx = CGFloat(col) * pitch
         let gy = CGFloat(row) * pitch
 
         switch slope {
         case .down:
             // Lines of constant (globalX − globalY); snap the generator
             // so that quantity is a multiple of `step` grid-wide.
             let lower = rect.minX - rect.height
             var x = firstAligned(at: lower, congruentTo: rect.minX - (gx - gy), step: step)
             while x <= rect.maxX {
                 path.move(to: CGPoint(x: x, y: rect.minY))
                 path.addLine(to: CGPoint(x: x + rect.height, y: rect.maxY))
                 x += step
             }
         case .up:
             // Lines of constant (globalX + globalY).
             let lower = rect.minX - rect.height
             var x = firstAligned(at: lower, congruentTo: lower - (gx + gy), step: step)
             while x <= rect.maxX {
                 path.move(to: CGPoint(x: x, y: rect.maxY))
                 path.addLine(to: CGPoint(x: x + rect.height, y: rect.minY))
                 x += step
             }
         case .horizontal:
             var y = firstAligned(at: rect.minY, congruentTo: rect.minY - gy, step: step)
             while y < rect.maxY {
                 path.move(to: CGPoint(x: rect.minX, y: y))
                 path.addLine(to: CGPoint(x: rect.maxX, y: y))
                 y += step
             }
         case .vertical:
             var x = firstAligned(at: rect.minX, congruentTo: rect.minX - gx, step: step)
             while x < rect.maxX {
                 path.move(to: CGPoint(x: x, y: rect.minY))
                 path.addLine(to: CGPoint(x: x, y: rect.maxY))
                 x += step
             }
         }
         return path
     }
 
     /// Smallest value ≥ `lower` that is congruent to `target` modulo
     /// `step`. Starting each run here puts every cell's lines on one
     /// shared global lattice, so they line up across cell borders.
     private func firstAligned(
         at lower: CGFloat,
         congruentTo target: CGFloat,
         step: CGFloat
     ) -> CGFloat {
         let delta = (target - lower).truncatingRemainder(dividingBy: step)
         let offset = delta >= 0 ? delta : delta + step
         return lower + offset
     }
 }
 
 /// Right-angled triangle pinned to the top-right corner of the cell, sized
 /// as a fraction of the shorter cell dimension. Used as a small marker for
 /// revealed and checkedWrong cells.
 private struct CornerTriangle: Shape {
     enum Corner { case topLeading, topTrailing }
     var corner: Corner = .topTrailing
     var fraction: CGFloat = 0.3
 
     func path(in rect: CGRect) -> Path {
         let side = min(rect.width, rect.height) * fraction
         var path = Path()
         switch corner {
         case .topTrailing:
             path.move(to: CGPoint(x: rect.maxX - side, y: rect.minY))
             path.addLine(to: CGPoint(x: rect.maxX, y: rect.minY))
             path.addLine(to: CGPoint(x: rect.maxX, y: rect.minY + side))
         case .topLeading:
             path.move(to: CGPoint(x: rect.minX, y: rect.minY))
             path.addLine(to: CGPoint(x: rect.minX + side, y: rect.minY))
             path.addLine(to: CGPoint(x: rect.minX, y: rect.minY + side))
         }
         path.closeSubpath()
         return path
     }
 }