crossmate

GameCardView.swift (10735B)

---

 import SwiftUI
 
 // MARK: - Card (regular width)
 
 enum CardMetrics {
     static let height: CGFloat = 88
     static let cornerRadius: CGFloat = 12
 }
 
 /// Tappable card used in the iPad grid layout. The card handles plain taps,
 /// while the participant swatch and overflow menu remain independent controls.
 struct GameCardView: View {
     let game: GameSummary
     let shareController: ShareController
     let usesRoomierType: Bool
     var onResume: () -> Void = {}
     var onLeave: () -> Void = {}
     var onResign: () -> Void = {}
     var onDelete: () -> Void = {}
     @State private var isShowingShareSheet = false
 
     var body: some View {
         let showsUnreadBadge = game.hasUnreadOtherMoves
 
         HStack(spacing: 12) {
             GameListThumbnailView(
                 game: game,
                 showsUnreadBadge: showsUnreadBadge
             )
             VStack(alignment: .leading, spacing: 2) {
                 HStack(spacing: 4) {
                     Text(game.title)
                         .font((usesRoomierType ? Font.headline : .subheadline).weight(.semibold))
                         .lineLimit(1)
                         .minimumScaleFactor(0.8)
                         .truncationMode(.tail)
                     if game.isShared {
                         SharedGameSymbol()
                     }
                 }
                 GameMetadataView(
                     puzzleDate: game.puzzleDate,
                     publisher: game.publisher,
                     usesRoomierType: usesRoomierType
                 )
                 if let date = game.updatedAt {
                     LastUpdatedView(date: date, usesRoomierType: usesRoomierType)
                 }
             }
             Spacer(minLength: 0)
             // Reserve room for the overflow menu, which is layered as an
             // overlay so its taps don't fall through to the card tap.
             Color.clear.frame(width: 32, height: 32)
         }
         .padding(12)
         .frame(maxWidth: .infinity)
         .frame(height: CardMetrics.height)
         .background(
             Color(.secondarySystemGroupedBackground),
             in: RoundedRectangle(cornerRadius: CardMetrics.cornerRadius)
         )
         .contentShape(RoundedRectangle(cornerRadius: CardMetrics.cornerRadius))
         .onTapGesture(perform: onResume)
         .overlay(alignment: .trailing) {
             GameOverflowMenu(
                 game: game,
                 onShare: { isShowingShareSheet = true },
                 onResume: onResume,
                 onLeave: onLeave,
                 onResign: onResign,
                 onDelete: onDelete
             )
             .padding(.trailing, 12)
         }
         .sheet(isPresented: $isShowingShareSheet) {
             GameShareSheet(
                 gameID: game.id,
                 title: game.title,
                 shareController: shareController
             )
         }
     }
 }
 
 struct GameListThumbnailView: View {
     let game: GameSummary
     let showsUnreadBadge: Bool
 
     private var showsParticipantStrip: Bool {
         game.isShared && game.completedAt == nil
     }
 
     var body: some View {
         VStack(spacing: 0) {
             GridThumbnailView(
                 width: game.gridWidth,
                 height: game.gridHeight,
                 cells: game.thumbnailCells,
                 size: 60
             )
             .overlay(alignment: .topTrailing) {
                 if showsUnreadBadge {
                     Circle()
                         .fill(.red)
                         .frame(width: 14, height: 14)
                         .overlay(
                             Circle()
                                 .stroke(.background, lineWidth: 2)
                         )
                         .offset(x: 5, y: -5)
                         .accessibilityLabel("Unseen changes")
                 }
             }
 
             if showsParticipantStrip {
                 SharedParticipantsButton(
                     stripParticipants: game.stripParticipants,
                     menuParticipants: game.allParticipants
                 )
                     .frame(width: 60)
                     .padding(.top, 2)
             }
         }
         .frame(width: 60)
     }
 }
 
 struct SharedGameSymbol: View {
     var body: some View {
         Image(systemName: "person.2.fill")
             .font(.caption.weight(.semibold))
             .foregroundStyle(.secondary)
             .accessibilityLabel("Shared puzzle")
     }
 }
 
 // MARK: - Shared overflow menu
 
 struct GameOverflowMenu: View {
     let game: GameSummary
     var onShare: () -> Void
     var onResume: () -> Void
     var onLeave: () -> Void
     var onResign: () -> Void
     var onDelete: () -> Void
 
     var body: some View {
         Menu {
             Button { onShare() } label: {
                 Label("Share", systemImage: "square.and.arrow.up")
             }
             .disabled(!game.isOwned)
             Button { onResume() } label: {
                 Label("Resume", systemImage: "puzzlepiece.extension")
             }
             Section {
                 Button(role: .destructive) { onResign() } label: {
                     Label("Resign", systemImage: "flag")
                 }
                 if !game.isOwned && game.isShared {
                     Button(role: .destructive) { onLeave() } label: {
                         Label("Leave", systemImage: "rectangle.portrait.and.arrow.right")
                     }
                 } else {
                     Button(role: .destructive) { onDelete() } label: {
                         Label("Delete", systemImage: "trash")
                     }
                 }
             }
         } label: {
             Image(systemName: "ellipsis")
                 .font(.body)
                 .frame(width: 32, height: 32)
                 .contentShape(Rectangle())
         }
         .tint(.secondary)
         .compositingGroup()
     }
 }
 
 struct SharedParticipantsButton: View {
     let stripParticipants: [GameParticipantSummary]
     let menuParticipants: [GameParticipantSummary]
     @State private var isShowingParticipants = false
 
     var body: some View {
         Button {
             isShowingParticipants = true
         } label: {
             ParticipantColorStrip(participants: stripParticipants)
         }
         .buttonStyle(.plain)
         .accessibilityLabel(accessibilityLabel)
         .popover(isPresented: $isShowingParticipants) {
             GameParticipantsPopover(participants: menuParticipants)
                 .presentationCompactAdaptation(.popover)
         }
     }
 
     private var accessibilityLabel: String {
         let remoteParticipants = menuParticipants.filter { !$0.isLocal }
         if remoteParticipants.isEmpty {
             return "Shared puzzle"
         }
         if remoteParticipants.count == 1, let participant = remoteParticipants.first {
             return "Shared with \(participant.name)"
         }
         return "Shared with \(remoteParticipants.count) players"
     }
 }
 
 private struct ParticipantColorStrip: View {
     @Environment(\.displayScale) private var displayScale
     let participants: [GameParticipantSummary]
 
     var body: some View {
         HStack(spacing: 0) {
             if participants.isEmpty {
                 Rectangle()
                     .fill(Color.secondary.opacity(0.35))
             } else {
                 ForEach(Array(participants.enumerated()), id: \.element.id) { index, participant in
                     if index > 0 {
                         Rectangle()
                             .fill(Color(.separator))
                             .frame(width: 1 / displayScale)
                     }
                     Rectangle()
                         .fill(participant.color.selectionFill)
                 }
             }
         }
         .frame(maxWidth: .infinity)
         .frame(height: 6)
         .contentShape(Rectangle())
     }
 }
 
 private struct GameParticipantsPopover: View {
     let participants: [GameParticipantSummary]
 
     var body: some View {
         VStack(alignment: .leading, spacing: 0) {
             Text("Players")
                 .font(.headline)
                 .padding(.horizontal, 16)
                 .padding(.top, 14)
                 .padding(.bottom, 8)
 
             if participants.isEmpty {
                 Text("Waiting for player...")
                     .font(.subheadline)
                     .foregroundStyle(.secondary)
                     .padding(.horizontal, 16)
                     .padding(.bottom, 16)
             } else {
                 VStack(spacing: 0) {
                     ForEach(participants) { participant in
                         HStack(spacing: 10) {
                             Circle()
                                 .fill(participant.color.selectionFill)
                                 .frame(width: 14, height: 14)
                             Text(participant.isLocal ? "\(participant.name) (you)" : participant.name)
                                 .font(.subheadline)
                                 .lineLimit(1)
                                 .truncationMode(.tail)
                             Spacer(minLength: 0)
                         }
                         .padding(.horizontal, 16)
                         .padding(.vertical, 9)
                     }
                 }
                 .padding(.bottom, 6)
             }
         }
         .frame(minWidth: 220, idealWidth: 260)
     }
 }
 
 struct GameMetadataView: View {
     let puzzleDate: Date?
     let publisher: String?
     let usesRoomierType: Bool
 
     private var font: Font {
         usesRoomierType ? .subheadline : .footnote
     }
 
     var body: some View {
         if let puzzleDate, let publisher {
             ViewThatFits(in: .horizontal) {
                 HStack(spacing: 0) {
                     Text(puzzleDate, format: .dateTime.day().month(.abbreviated).year())
                     Text(" • ")
                     Text(publisher)
                 }
                 .font(font)
                 .lineLimit(1)
 
                 VStack(alignment: .leading, spacing: 2) {
                     puzzleDateView(puzzleDate)
                     publisherView(publisher)
                 }
             }
         } else {
             if let puzzleDate {
                 puzzleDateView(puzzleDate)
             }
             if let publisher {
                 publisherView(publisher)
             }
         }
     }
 
     private func puzzleDateView(_ puzzleDate: Date) -> some View {
         Text(puzzleDate, format: .dateTime.day().month(.abbreviated).year())
             .font(font)
     }
 
     private func publisherView(_ publisher: String) -> some View {
         Text(publisher)
             .font(font)
             .lineLimit(1)
             .truncationMode(.tail)
     }
 }