crossmate

GameCardView.swift (14719B)

---

 import SwiftUI
 
 // MARK: - Card (regular width)
 
 enum CardMetrics {
     static let height: CGFloat = 110
     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(.headline)
                         .lineLimit(1)
                         .minimumScaleFactor(0.9)
                         .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)
         }
         .gameSummaryAccessibility(
             game: game,
             onInvite: { isShowingShareSheet = true },
             onOpen: onResume,
             onLeave: onLeave,
             onResign: onResign,
             onDelete: onDelete
         )
         .sheet(isPresented: $isShowingShareSheet) {
             GameShareSheet(
                 gameID: game.id,
                 title: game.title,
                 shareController: shareController
             )
         }
     }
 }
 
 private struct GameSummaryAccessibility: ViewModifier {
     let game: GameSummary
     let onInvite: () -> Void
     let onOpen: () -> Void
     let onLeave: () -> Void
     let onResign: () -> Void
     let onDelete: () -> Void
 
     private var isCompleted: Bool {
         game.completedAt != nil
     }
 
     private var shouldLeaveShare: Bool {
         !isCompleted && !game.isOwned && game.isShared
     }
 
     func body(content: Content) -> some View {
         content
             .accessibilityElement(children: .ignore)
             .accessibilityLabel(accessibilityLabel)
             .accessibilityHint(isCompleted ? "Opens completed puzzle" : "Opens puzzle")
             .accessibilityAddTraits(.isButton)
             .accessibilityAction {
                 onOpen()
             }
             .accessibilityActions {
                 if !isCompleted, game.isOwned {
                     Button("Invite", action: onInvite)
                 }
                 Button(isCompleted ? "View" : "Resume", action: onOpen)
                 if !isCompleted {
                     Button("Resign", role: .destructive, action: onResign)
                 }
                 if shouldLeaveShare {
                     Button("Leave", role: .destructive, action: onLeave)
                 } else {
                     Button("Delete", role: .destructive, action: onDelete)
                 }
             }
     }
 
     private var accessibilityLabel: String {
         var parts: [String] = [game.title]
         if game.isAccessRevoked {
             parts.append("access revoked")
         } else if isCompleted {
             parts.append("completed")
         } else {
             parts.append("in progress")
         }
         if game.hasUnreadOtherMoves {
             parts.append("unseen changes")
         }
         if let sharedSummary {
             parts.append(sharedSummary)
         }
         if let publisher = game.publisher, !publisher.isEmpty {
             parts.append(publisher)
         }
         if let puzzleDate = game.puzzleDate {
             parts.append(puzzleDate.formatted(.dateTime.day().month(.wide).year()))
         }
         if let updatedAt = game.updatedAt {
             parts.append(lastUpdatedText(from: updatedAt))
         }
         return parts.joined(separator: ", ")
     }
 
     private var sharedSummary: String? {
         guard game.isShared else { return nil }
         let remoteParticipants = game.allParticipants.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 func lastUpdatedText(from date: Date) -> String {
         let elapsed = max(0, Date.now.timeIntervalSince(date))
         if elapsed < 60 {
             let seconds = max(1, Int(elapsed.rounded(.down)))
             return "last updated \(seconds) \(seconds == 1 ? "second" : "seconds") ago"
         }
         if elapsed < 60 * 60 {
             let minutes = Int((elapsed / 60).rounded(.down))
             return "last updated \(minutes) \(minutes == 1 ? "minute" : "minutes") ago"
         }
         if elapsed <= 48 * 60 * 60 {
             let hours = Int((elapsed / (60 * 60)).rounded(.down))
             return "last updated \(hours) \(hours == 1 ? "hour" : "hours") ago"
         }
         return "last updated on \(date.formatted(.dateTime.day().month(.wide).year()))"
     }
 }
 
 extension View {
     func gameSummaryAccessibility(
         game: GameSummary,
         onInvite: @escaping () -> Void,
         onOpen: @escaping () -> Void,
         onLeave: @escaping () -> Void,
         onResign: @escaping () -> Void,
         onDelete: @escaping () -> Void
     ) -> some View {
         modifier(GameSummaryAccessibility(
             game: game,
             onInvite: onInvite,
             onOpen: onOpen,
             onLeave: onLeave,
             onResign: onResign,
             onDelete: onDelete
         ))
     }
 }
 
 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
 
     private var isCompleted: Bool {
         game.completedAt != nil
     }
 
     private var shouldLeaveShare: Bool {
         !isCompleted && !game.isOwned && game.isShared
     }
 
     var body: some View {
         Menu {
             if !isCompleted {
                 Button { onShare() } label: {
                     Label("Invite", systemImage: "plus.square")
                 }
                 .disabled(!game.isOwned)
             }
             Button { onResume() } label: {
                 if isCompleted {
                     Label("View", systemImage: "binoculars")
                 } else {
                     Label("Resume", systemImage: "puzzlepiece.extension")
                 }
             }
             Section {
                 if !isCompleted {
                     Button(role: .destructive) { onResign() } label: {
                         Label("Resign", systemImage: "flag")
                     }
                 }
                 if shouldLeaveShare {
                     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 {
             Text(puzzleDate, format: .dateTime.day().month(.abbreviated).year())
                 .font(font)
                 .foregroundStyle(.secondary)
         }
         if let publisher {
             Text(publisher)
                 .font(font)
                 .foregroundStyle(.secondary)
                 .lineLimit(1)
                 .truncationMode(.tail)
         }
     }
 }