crossmate

PuzzleModifiers.swift (14463B)

---

 import SwiftUI
 
 struct PuzzleToolbarModifier: ViewModifier {
     let session: PlayerSession
     let roster: PlayerRoster
     let shareController: ShareController?
     let isSolved: Bool
     let canResign: Bool
     let canDelete: Bool
     /// Sends a broadcast nudge to the other players; `nil` hides the button
     /// (solo/test sessions).
     var onNudge: (() async -> Void)? = nil
     /// Whether a nudge is allowed right now (cooldown elapsed). Read when the
     /// menu is built.
     var nudgeReadyAt: () -> Date? = { nil }
     @Binding var isRenaming: Bool
     @Binding var renameDraft: String
     @Binding var isConfirmingResign: Bool
     @Binding var isConfirmingDelete: Bool
     @Binding var isConfirmingLeave: Bool
     @Binding var isConfirmingReveal: Bool
     @Binding var pendingRevealScope: RevealScope
     @Binding var isShowingShareSheet: Bool
     @Environment(PlayerPreferences.self) private var preferences
     @AppStorage("debugMode") private var debugMode = false
     @State private var isShowingDiagnostics = false
 
     func body(content: Content) -> some View {
         content
             .toolbar {
                 ToolbarItemGroup(placement: .topBarTrailing) {
                     pencilButton
                     entryMenu
                     hintsMenu
                     playersMenu
                 }
             }
             .sheet(isPresented: $isShowingDiagnostics) {
                 NavigationStack {
                     DiagnosticsView()
                         .toolbar {
                             ToolbarItem(placement: .cancellationAction) {
                                 Button {
                                     isShowingDiagnostics = false
                                 } label: {
                                     Image(systemName: "xmark")
                                 }
                                 .accessibilityLabel("Close")
                             }
                         }
                 }
             }
     }
 
     private func swatchImage(for color: PlayerColor) -> Image {
         let tint = UIColor(color.tint)
         let base = UIImage(systemName: "circle.fill") ?? UIImage()
         return Image(uiImage: base.withTintColor(tint, renderingMode: .alwaysOriginal))
     }
 
     private var pencilButton: some View {
         Button {
             session.togglePencil()
         } label: {
             Image(systemName: "pencil")
                 .foregroundStyle(pencilButtonForeground)
                 .padding(6)
                 .pencilGlass(
                     isActive: !isSolved && session.isPencilMode,
                     tint: preferences.color.tint
                 )
         }
         .accessibilityLabel("Pencil")
         .disabled(isSolved)
     }
 
     private var pencilButtonForeground: Color {
         if isSolved {
             return .secondary
         }
         if session.isPencilMode {
             return .white
         }
         if #available(iOS 26.0, *) {
             return .primary
         }
         return .accentColor
     }
 
     private var entryMenu: some View {
         Menu {
             Section {
                 Button("Undo Move") { session.undo() }
                     .disabled(!session.canUndo)
                 Button("Redo Move") { session.redo() }
                     .disabled(!session.canRedo)
             }
 
             Section {
                 Button("Enter Rebus") { session.startRebus() }
                 Button("Toggle Direction") { session.toggleDirection() }
             }
 
             if debugMode {
                 Section {
                     Button {
                         isShowingDiagnostics = true
                     } label: {
                         Text("Diagnostics Log")
                     }
                 }
             }
 
             Section {
                 Button("Clear Word") { session.clearCurrentWord() }
                 Button("Clear Puzzle", role: .destructive) { session.clearPuzzle() }
             }
         } label: {
             Label("Entry", systemImage: "squareshape.split.2x2")
         }
         .disabled(isSolved)
     }
 
     private var hintsMenu: some View {
         Menu {
             Section {
                 Button("Check Square") { session.checkSquare() }
                 Button("Check Word") { session.checkCurrentWord() }
                 Button("Check Puzzle") { session.checkPuzzle() }
             }
             Section {
                 Button("Reveal Square") { confirmReveal(.square) }
                 Button("Reveal Word") { confirmReveal(.word) }
                 Button("Reveal Puzzle") { confirmReveal(.puzzle) }
             }
         } label: {
             Label("Hints", systemImage: "lightbulb")
         }
         .disabled(isSolved)
     }
 
     private func confirmReveal(_ scope: RevealScope) {
         pendingRevealScope = scope
         isConfirmingReveal = true
     }
 
     private var playersMenu: some View {
         Menu {
             playerRosterSection
             playerPreferencesSection
             shareSection
             puzzleDestructiveSection
         } label: {
             Label("Players", systemImage: "person.2")
         }
         .disabled(isSolved)
     }
 
     @ViewBuilder
     private var playerRosterSection: some View {
         Section {
             if !roster.entries.isEmpty {
                 ForEach(roster.entries) { entry in
                     Button {} label: {
                         Label {
                             Text(entry.isLocal ? "\(entry.name) (you)" : entry.name)
                         } icon: {
                             swatchImage(for: entry.color)
                         }
                     }
                     .disabled(true)
                 }
             } else {
                 Button {} label: {
                     Label {
                         Text(preferences.name)
                     } icon: {
                         swatchImage(for: preferences.color)
                     }
                 }
                 .disabled(true)
             }
         }
         nudgeSection
     }
 
     /// Broadcast "Nudge Players" action. Shown only when nudging is wired up
     /// (a shared session) and there is at least one other player to rouse;
     /// disabled while the puzzle is solved or the per-game cooldown is still
     /// running. The Menu rebuilds each time it opens, so `nudgeReadyAt()` is read
     /// fresh and the disabled state tracks the cooldown without observation.
     @ViewBuilder
     private var nudgeSection: some View {
         if let onNudge, roster.entries.contains(where: { !$0.isLocal }) {
             Section {
                 Button("Nudge Players") {
                     Task { await onNudge() }
                 }
                 .disabled(isSolved || nudgeReadyAt() != nil)
             }
         }
     }
 
     private var playerPreferencesSection: some View {
         Section {
             Menu("Change Colour") {
                 ForEach(PlayerColor.palette) { color in
                     Button {
                         preferences.color = color
                         // Friend colours are derived with the local user's
                         // colour reserved, so refreshing re-derives and bumps
                         // any friend that now collides with the new choice.
                         Task { await roster.refresh() }
                     } label: {
                         Label {
                             Text(color.id == preferences.colorID ? "\(color.name)  ✓" : color.name)
                         } icon: {
                             swatchImage(for: color)
                         }
                     }
                 }
             }
 
             Button("Change Name") {
                 renameDraft = preferences.name
                 isRenaming = true
             }
         }
     }
 
     @ViewBuilder
     private var shareSection: some View {
         if shareController != nil {
             Section {
                 Button {
                     isShowingShareSheet = true
                 } label: {
                     Text("Share Puzzle")
                 }
                 .disabled(!session.mutator.isOwned)
             }
         }
     }
 
     private var puzzleDestructiveSection: some View {
         Section {
             Button("Resign Puzzle", role: .destructive) {
                 isConfirmingResign = true
             }
             .disabled(isSolved || !canResign)
 
             if session.mutator.isShared && !session.mutator.isOwned {
                 Button("Leave Puzzle", role: .destructive) {
                     isConfirmingLeave = true
                 }
                 .disabled(shareController == nil)
             } else {
                 Button("Delete Puzzle", role: .destructive) {
                     isConfirmingDelete = true
                 }
                 .disabled(!canDelete)
             }
         }
     }
 }
 
 struct PuzzleLifecycleModifier: ViewModifier {
     let session: PlayerSession
     let roster: PlayerRoster
     @Binding var hasSolved: Bool
     let onCompletionEvent: (PlayerSession.CompletionEvent) -> Void
     let onSolvedOnAppear: () -> Void
 
     func body(content: Content) -> some View {
         content
             .task {
                 await roster.refresh()
             }
             .onAppear {
                 if session.game.completionState == .solved {
                     hasSolved = true
                     onSolvedOnAppear()
                 }
             }
             .onChange(of: session.completionEvent) { _, newValue in
                 guard let newValue else { return }
                 onCompletionEvent(newValue)
             }
     }
 }
 
 struct PuzzlePresentationModifier: ViewModifier {
     let session: PlayerSession
     let shareController: ShareController?
     @Binding var isRenaming: Bool
     @Binding var renameDraft: String
     @Binding var showErrorsAlert: Bool
     @Binding var isConfirmingResign: Bool
     @Binding var isConfirmingDelete: Bool
     @Binding var isConfirmingLeave: Bool
     @Binding var isConfirmingReveal: Bool
     @Binding var pendingRevealScope: RevealScope
     @Binding var leaveError: String?
     @Binding var destructiveActionError: String?
     @Binding var isShowingShareSheet: Bool
     let performResign: () -> Void
     let performDelete: () -> Void
     let leaveSharedGame: () async -> Void
     @Environment(PlayerPreferences.self) private var preferences
 
     func body(content: Content) -> some View {
         content
             .alert("Not Quite Right", isPresented: $showErrorsAlert) {
                 Button("OK", role: .cancel) {}
             } message: {
                 Text("One or more squares are incorrect.")
             }
             .alert("Resign Puzzle?", isPresented: $isConfirmingResign) {
                 Button("Resign", role: .destructive) {
                     performResign()
                 }
                 Button("Cancel", role: .cancel) {}
             } message: {
                 Text("This will reveal the puzzle and mark it complete.")
             }
             .alert("Delete Puzzle?", isPresented: $isConfirmingDelete) {
                 Button("Delete", role: .destructive) {
                     performDelete()
                 }
                 Button("Cancel", role: .cancel) {}
             } message: {
                 deleteConfirmationMessage
             }
             .alert("Leave Puzzle?", isPresented: $isConfirmingLeave) {
                 Button("Leave", role: .destructive) {
                     Task { await leaveSharedGame() }
                 }
                 Button("Cancel", role: .cancel) {}
             } message: {
                 Text("You will lose access to \"\(session.puzzle.title)\".")
             }
             .alert(pendingRevealScope.title, isPresented: $isConfirmingReveal) {
                 Button("Reveal", role: .destructive) {
                     performReveal(pendingRevealScope)
                 }
                 Button("Cancel", role: .cancel) {}
             } message: {
                 Text(pendingRevealScope.message)
             }
             .alert(
                 "Couldn't Leave",
                 isPresented: .init(
                     get: { leaveError != nil },
                     set: { if !$0 { leaveError = nil } }
                 ),
                 presenting: leaveError
             ) { _ in
                 Button("OK", role: .cancel) {}
             } message: { message in
                 Text(message)
             }
             .alert(
                 "Couldn't Update Puzzle",
                 isPresented: .init(
                     get: { destructiveActionError != nil },
                     set: { if !$0 { destructiveActionError = nil } }
                 ),
                 presenting: destructiveActionError
             ) { _ in
                 Button("OK", role: .cancel) {}
             } message: { message in
                 Text(message)
             }
             .alert("Change Name", isPresented: $isRenaming) {
                 TextField("Name", text: $renameDraft)
                     .textInputAutocapitalization(.never)
                     .autocorrectionDisabled()
                 Button("Cancel", role: .cancel) {}
                 Button("Save") {
                     let trimmed = renameDraft.trimmingCharacters(in: .whitespacesAndNewlines)
                     if !trimmed.isEmpty {
                         preferences.name = trimmed
                     }
                 }
                 .keyboardShortcut(.defaultAction)
             } message: {
                 Text("Enter the name other players will see.")
             }
             .sheet(isPresented: $isShowingShareSheet) {
                 if let shareController {
                     GameShareSheet(
                         gameID: session.mutator.gameID,
                         title: session.puzzle.title,
                         shareController: shareController
                     )
                 }
             }
     }
 
     private func performReveal(_ scope: RevealScope) {
         switch scope {
         case .square: session.revealSquare()
         case .word: session.revealCurrentWord()
         case .puzzle: session.revealPuzzle()
         }
     }
 
     private var deleteConfirmationMessage: Text {
         if session.mutator.isOwned && session.mutator.isShared {
             Text("This will permanently delete \"\(session.puzzle.title)\" from iCloud for everyone.")
         } else {
             Text("This will permanently delete \"\(session.puzzle.title)\" and all progress.")
         }
     }
 }