crossmate

CellView.swift (6376B)

---

 import SwiftUI
 
 struct CellView: View, Equatable {
     let cell: Puzzle.Cell
     let entry: String
     let mark: CellMark
     let isSelected: Bool
     let isHighlighted: Bool
     var isRelatedToFocus: Bool = false
     let specialKind: Puzzle.Special?
     var remoteWordTint: Color? = nil
     var remoteOutline: Color? = nil
     var authorTint: Color? = nil
 
     @Environment(PlayerPreferences.self) private var preferences
     private var playerColor: PlayerColor { preferences.color }
 
     nonisolated static func == (lhs: CellView, rhs: CellView) -> Bool {
         lhs.cell == rhs.cell
             && lhs.entry == rhs.entry
             && lhs.mark == rhs.mark
             && lhs.isSelected == rhs.isSelected
             && lhs.isHighlighted == rhs.isHighlighted
             && lhs.isRelatedToFocus == rhs.isRelatedToFocus
             && lhs.specialKind == rhs.specialKind
             && lhs.remoteWordTint == rhs.remoteWordTint
             && lhs.remoteOutline == rhs.remoteOutline
             && lhs.authorTint == rhs.authorTint
     }
 
     var body: some View {
         ZStack(alignment: .topLeading) {
             background
             if !cell.isBlock {
                 if cell.isSpecial && specialKind == .circled {
                     Circle()
                         .stroke(Color.black.opacity(0.55), lineWidth: 1)
                         .padding(1.5)
                 }
                 if cell.number != nil {
                     CornerDot()
                         .fill(Color(.systemGray3))
                 }
                 Text(entry)
                     .font(.system(size: 34, weight: .semibold, design: .rounded))
                     .foregroundStyle(entryStyle)
                     .lineLimit(1)
                     .minimumScaleFactor(0.2)
                     .allowsTightening(true)
                     .padding(.horizontal, 2)
                     .frame(maxWidth: .infinity, maxHeight: .infinity)
                 if let triangleColor = cornerTriangleColor {
                     CornerTriangle()
                         .fill(triangleColor)
                 }
                 if isRelatedToFocus {
                     Rectangle()
                         .strokeBorder(playerColor.highlightFill, lineWidth: 3)
                 }
                 if let remoteOutline {
                     Rectangle()
                         .strokeBorder(remoteOutline, lineWidth: 2)
                 }
             }
         }
         .frame(maxWidth: .infinity, maxHeight: .infinity)
         .contentShape(Rectangle())
     }
 
     /// Foreground style for the main entry letter. Pencil entries use the
     /// hierarchical `.secondary` style so they render lighter and respect
     /// dark mode; everything else — including revealed and checkedWrong
     /// cells — uses the primary label colour. 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(HierarchicalShapeStyle.secondary)
         case .none, .pen, .revealed:
             return AnyShapeStyle(HierarchicalShapeStyle.primary)
         }
     }
 
     /// 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
     }
 
     @ViewBuilder
     private var background: some View {
         if cell.isBlock {
             Color.black
         } else {
             ZStack {
                 Color.white
                 if cell.isSpecial && specialKind == .shaded {
                     Color.black.opacity(0.22)
                 }
                 // Faint background tint identifying who entered this letter
                 // in a shared game. Sits beneath transient highlights so peer
                 // and local cursors still dominate.
                 if let authorTint {
                     authorTint.opacity(0.10)
                 }
                 // Peer word tint sits beneath self highlight/selection so the
                 // local cursor always reads as the dominant focus.
                 if let remoteWordTint {
                     remoteWordTint
                 }
                 if isSelected {
                     playerColor.selectionFill
                 } else if isHighlighted {
                     playerColor.highlightFill
                 }
             }
         }
     }
 }
 
 /// Small dot pinned to the top-leading corner of the cell, sized as a
 /// fraction of the shorter cell dimension. Marks cells that start a word.
 private struct CornerDot: Shape {
     var diameterFraction: CGFloat = 0.15
     var insetFraction: CGFloat = 0.05
 
     func path(in rect: CGRect) -> Path {
         let side = min(rect.width, rect.height)
         let diameter = side * diameterFraction
         let inset = side * insetFraction
         var path = Path()
         path.addEllipse(in: CGRect(
             x: rect.minX + inset,
             y: rect.minY + inset,
             width: diameter,
             height: diameter
         ))
         return path
     }
 }
 
 /// 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
     }
 }