crossmate

SuccessPanel.swift (7099B)

---

 import SwiftUI
 
 struct SuccessPanel: View {
     let session: PlayerSession
     let roster: PlayerRoster
     @Environment(PlayerPreferences.self) private var preferences
 
     private struct Contribution: Identifiable {
         let authorID: String?
         let name: String
         let color: PlayerColor?
         let count: Int
 
         var id: String { authorID ?? "unattributed" }
     }
 
     private var revealedSquareCount: Int {
         var count = 0
         for r in 0..<session.puzzle.height {
             for c in 0..<session.puzzle.width {
                 let cell = session.puzzle.cells[r][c]
                 guard !cell.isBlock else { continue }
                 if session.game.squares[r][c].mark.isRevealed {
                     count += 1
                 }
             }
         }
         return count
     }
 
     private var revealedSquaresText: String {
         switch revealedSquareCount {
         case 0:
             return "No squares revealed"
         case 1:
             return "1 square revealed"
         default:
             return "\(revealedSquareCount) squares revealed"
         }
     }
 
     private var contributions: [Contribution] {
         var counts: [String?: Int] = [:]
         for r in 0..<session.puzzle.height {
             for c in 0..<session.puzzle.width {
                 let cell = session.puzzle.cells[r][c]
                 guard !cell.isBlock else { continue }
                 let square = session.game.squares[r][c]
                 guard !square.mark.isRevealed else { continue }
                 let entry = square.entry
                 guard !entry.isEmpty else { continue }
                 if cell.solution != nil, !cell.accepts(entry) { continue }
                 counts[normalizedAuthorID(square.letterAuthorID), default: 0] += 1
             }
         }
 
         let entries = roster.entries
         let entryByAuthorID = Dictionary(uniqueKeysWithValues: entries.map { ($0.authorID, $0) })
         let hasRemotePlayers = entries.contains { !$0.isLocal }
         let usesLocalFallback = entries.isEmpty
         let rosterContributions: [Contribution]
         if usesLocalFallback {
             rosterContributions = [
                 Contribution(
                     authorID: nil,
                     name: preferences.name,
                     color: preferences.color,
                     count: counts[nil] ?? 0
                 )
             ]
         } else {
             rosterContributions = entries.map { entry in
                 Contribution(
                     authorID: entry.authorID,
                     name: entry.name,
                     color: entry.color,
                     count: counts[entry.authorID] ?? 0
                 )
             }
         }
         let rosterAuthorIDs = Set(entries.map(\.authorID))
 
         let countedContributions = counts.compactMap { authorID, count -> Contribution? in
             if let authorID, rosterAuthorIDs.contains(authorID) {
                 return nil
             }
             if authorID == nil && usesLocalFallback {
                 return nil
             }
             if let authorID, let entry = entryByAuthorID[authorID] {
                 return Contribution(authorID: authorID, name: entry.name, color: entry.color, count: count)
             }
             if authorID == nil && !hasRemotePlayers {
                 return Contribution(authorID: nil, name: preferences.name, color: preferences.color, count: count)
             }
             return Contribution(authorID: authorID, name: "Player", color: nil, count: count)
         }
 
         return (rosterContributions + countedContributions)
         .sorted {
             if $0.count != $1.count { return $0.count > $1.count }
             return $0.name < $1.name
         }
     }
 
     private func normalizedAuthorID(_ authorID: String?) -> String? {
         guard let authorID else {
             return roster.entries.contains(where: { !$0.isLocal }) ? nil : roster.localAuthorID
         }
         return authorID
     }
 
     var body: some View {
         HStack(alignment: .center, spacing: 16) {
             VStack(alignment: .center, spacing: 8) {
                 Image(systemName: "checkmark.seal.fill")
                     .font(.system(size: 44))
                     .foregroundStyle(.tint)
 
                 VStack(alignment: .center, spacing: 2) {
                     Text(session.puzzle.title)
                         .font(.subheadline.weight(.semibold))
                         .lineLimit(1)
                     if let date = session.puzzle.date {
                         Text(date, format: .dateTime.day().month(.abbreviated).year())
                             .font(.caption)
                             .foregroundStyle(.secondary)
                             .lineLimit(1)
                     }
                     if let author = session.puzzle.author {
                         Text(author)
                             .font(.caption)
                             .foregroundStyle(.secondary)
                             .lineLimit(1)
                     }
                     if let publisher = session.puzzle.publisher {
                         Text(publisher)
                             .font(.caption)
                             .foregroundStyle(.secondary)
                             .lineLimit(1)
                     }
                 }
                 .multilineTextAlignment(.center)
                 .frame(maxWidth: .infinity, alignment: .center)
             }
             .frame(maxWidth: .infinity, alignment: .center)
 
             VStack(alignment: .leading, spacing: 12) {
                 Text("Players")
                     .font(.headline)
 
                 ScrollView {
                     VStack(alignment: .leading, spacing: 6) {
                         ForEach(contributions) { contribution in
                             HStack(spacing: 8) {
                                 Circle()
                                     .fill(contribution.color?.tint ?? Color.secondary)
                                     .frame(width: 8, height: 8)
                                 Text(contribution.name)
                                     .font(.subheadline)
                                     .lineLimit(1)
                                 Spacer(minLength: 8)
                                 Text("\(contribution.count)")
                                     .font(.subheadline.monospacedDigit().weight(.semibold))
                             }
                         }
 
                         Text(revealedSquaresText)
                             .font(.footnote)
                             .foregroundStyle(.secondary)
                             .padding(.top, 16)
                             .frame(maxWidth: .infinity, alignment: .center)
                     }
                 }
                 .scrollIndicators(.hidden)
             }
             .frame(maxWidth: .infinity, alignment: .leading)
             .padding(.top, 8)
         }
         .padding(.leading, 18)
         .padding(.trailing, 24)
         .padding(.vertical, 10)
         .frame(maxWidth: .infinity, maxHeight: .infinity)
     }
 }