Crossmate/Views/Puzzle/PuzzleView.swift (30409B)
1import SwiftUI
2
3enum RevealScope {
4 case square
5 case word
6 case puzzle
7
8 var title: String {
9 switch self {
10 case .square: "Reveal Square?"
11 case .word: "Reveal Word?"
12 case .puzzle: "Reveal Puzzle?"
13 }
14 }
15
16 var message: String {
17 switch self {
18 case .square: "This will reveal the current square."
19 case .word: "This will reveal the current word."
20 case .puzzle: "This will reveal the entire puzzle and mark it complete."
21 }
22 }
23}
24
25struct PuzzleView: View {
26 @Bindable var session: PlayerSession
27 var shareController: ShareController? = nil
28 let roster: PlayerRoster
29 var onComplete: ((_ notifyPeers: Bool) -> Void)? = nil
30 var onResign: (() throws -> Void)? = nil
31 var onDelete: (() throws -> Void)? = nil
32
33
34 var onNudge: (() async -> Void)? = nil
35
36
37
38 var nudgeReadyAt: () -> Date? = { nil }
39
40
41 var loadReplay: () async -> JournalReplayResult = { .unavailable }
42
43
44
45 var loadRecentChanges: () -> [GridPosition: String] = { [:] }
46
47
48 var markPuzzleViewed: () -> Void = {}
49 @Environment(InputMonitor.self) private var inputMonitor
50 @Environment(PlayerPreferences.self) private var preferences
51 @Environment(AnnouncementCenter.self) private var announcements
52 @Environment(\.dismiss) private var dismiss
53 @Environment(\.accessibilityVoiceOverEnabled) private var isVoiceOverEnabled
54 @State private var isRenaming = false
55 @State private var renameDraft = ""
56 @State private var showErrorsAlert = false
57 @State private var isConfirmingResign = false
58 @State private var isConfirmingDelete = false
59 @State private var isConfirmingLeave = false
60 @State private var revealConfirmation = RevealConfirmation()
61 @State private var isConfirmingClear = false
62 @State private var leaveError: String?
63 @State private var destructiveActionError: String?
64 @State private var isShowingShareSheet = false
65 @State private var hasSolved = false
66 @State private var replay = ReplayControls()
67 @State private var padLayout: PadLayout?
68
69
70
71
72 @State private var lastActiveSize: CGSize = .zero
73
74
75 @State private var isArmed = false
76 @State private var announcedIntroGameID: UUID?
77
78
79
80 @FocusState private var isRebusFieldFocused: Bool
81 @Environment(\.engagementStatus) private var engagementStatus
82 @Environment(\.scenePhase) private var scenePhase
83
84 private enum PadLayout: Equatable {
85 case landscape
86 case portrait
87 }
88
89 private var effectivePadLayout: PadLayout? {
90 guard UIDevice.current.userInterfaceIdiom == .pad else { return nil }
91 return padLayout ?? .portrait
92 }
93
94 private func swatchImage(for color: PlayerColor) -> Image {
95 let tint = UIColor(color.tint)
96 let base = UIImage(systemName: "circle.fill") ?? UIImage()
97 return Image(uiImage: base.withTintColor(tint, renderingMode: .alwaysOriginal))
98 }
99
100 private struct TitleParts {
101 let title: String
102 let subtitle: String?
103 }
104
105 private var titleParts: TitleParts {
106 let title = session.puzzle.title
107 let formattedDate = session.puzzle.date?.formatted(date: .long, time: .omitted)
108 let subtitle: String?
109 if let publisher = session.puzzle.publisher, let formattedDate {
110 subtitle = "\(publisher) · \(formattedDate)"
111 } else if let publisher = session.puzzle.publisher {
112 subtitle = publisher
113 } else {
114 subtitle = formattedDate
115 }
116 return TitleParts(title: title, subtitle: subtitle)
117 }
118
119
120
121
122 private var isSolved: Bool { hasSolved || session.mutator.isCompleted }
123
124
125
126
127
128
129
130 private var isInputBlocked: Bool {
131 !session.mutator.isEditable
132 || announcements.isInputBlocked(forGame: session.mutator.gameID)
133 }
134
135 private var shouldAutoRevealScoreboard: Bool {
136 onNudge != nil && !isSolved && roster.entries.contains(where: { !$0.isLocal })
137 }
138
139 var body: some View {
140 Group {
141 switch effectivePadLayout {
142 case .landscape:
143 landscapePadLayout
144 case .portrait:
145 portraitPadLayout
146 case .none:
147 phoneLayout
148 }
149 }
150 .background(Color(.systemBackground))
151 .background {
152
153
154 HardwareKeyboardInputView(
155 onPress: handleHardwareKeyboardEvent,
156 isActive: !session.isRebusActive
157 )
158 .frame(width: 0, height: 0)
159 .allowsHitTesting(false)
160 }
161 .ignoresSafeArea(.keyboard)
162 .onChange(of: session.isRebusActive) { _, active in
163 isRebusFieldFocused = active
164 }
165 .onChange(of: isRebusFieldFocused) { _, focused in
166
167
168 if !focused, session.isRebusActive {
169 session.commitRebus()
170 }
171 }
172 .modifier(PuzzleToolbarModifier(
173 session: session,
174 roster: roster,
175 shareController: shareController,
176 isSolved: isSolved,
177 isEditingBlocked: isSolved || isInputBlocked,
178 canResign: onResign != nil,
179 canDelete: onDelete != nil,
180 onNudge: onNudge,
181 nudgeReadyAt: nudgeReadyAt,
182 isRenaming: $isRenaming,
183 renameDraft: $renameDraft,
184 isConfirmingResign: $isConfirmingResign,
185 isConfirmingDelete: $isConfirmingDelete,
186 isConfirmingLeave: $isConfirmingLeave,
187 revealConfirmation: revealConfirmation,
188 isConfirmingClear: $isConfirmingClear,
189 isShowingShareSheet: $isShowingShareSheet
190 ))
191 .modifier(PuzzleLifecycleModifier(
192 session: session,
193 roster: roster,
194 hasSolved: $hasSolved,
195 onCompletionEvent: handleCompletionEvent,
196 onSolvedOnAppear: {
197 onComplete?(false)
198 }
199 ))
200 .modifier(PuzzlePresentationModifier(
201 session: session,
202 shareController: shareController,
203 isRenaming: $isRenaming,
204 renameDraft: $renameDraft,
205 showErrorsAlert: $showErrorsAlert,
206 isConfirmingResign: $isConfirmingResign,
207 isConfirmingDelete: $isConfirmingDelete,
208 isConfirmingLeave: $isConfirmingLeave,
209 revealConfirmation: revealConfirmation,
210 isConfirmingClear: $isConfirmingClear,
211 leaveError: $leaveError,
212 destructiveActionError: $destructiveActionError,
213 isShowingShareSheet: $isShowingShareSheet,
214 performResign: performResign,
215 performDelete: performDelete,
216 leaveSharedGame: leaveSharedGame
217 ))
218
219
220
221 .focusedSceneValue(\.puzzleActions, PuzzleActionTarget(
222 session: session,
223 revealConfirmation: revealConfirmation,
224 isEnabled: !isSolved && !isInputBlocked
225 ))
226 .frame(
227 width: scenePhase == .active || lastActiveSize == .zero ? nil : lastActiveSize.width,
228 height: scenePhase == .active || lastActiveSize == .zero ? nil : lastActiveSize.height
229 )
230 .onGeometryChange(for: CGSize.self) { proxy in
231 proxy.size
232 } action: { newSize in
233 if UIApplication.shared.applicationState == .active {
234 lastActiveSize = newSize
235 }
236 updateLayoutTrait(for: newSize)
237 }
238 .onChange(of: scenePhase) { _, newPhase in
239
240
241 if newPhase == .active {
242 updateLayoutTrait(for: lastActiveSize, force: true)
243 }
244 }
245 .onAppear {
246 session.onRecentChangesAcknowledged = markPuzzleViewed
247 }
248 .task(id: session.mutator.gameID) {
249 announcePuzzleIntroIfNeeded()
250
251
252
253
254
255 isArmed = false
256 try? await Task.sleep(for: .milliseconds(750))
257 isArmed = true
258 if session.mutator.isShared {
259 session.recentChanges = loadRecentChanges()
260 }
261 }
262 }
263
264 private func announcePuzzleIntroIfNeeded() {
265 guard isVoiceOverEnabled,
266 announcedIntroGameID != session.mutator.gameID
267 else { return }
268 announcedIntroGameID = session.mutator.gameID
269 AccessibilityNotification.Announcement(puzzleIntroAnnouncement).post()
270 }
271
272 private var puzzleIntroAnnouncement: String {
273 var parts = [
274 titleParts.title,
275 "\(session.puzzle.width) by \(session.puzzle.height) puzzle"
276 ]
277 if let shared = sharedPlayersAnnouncement {
278 parts.append(shared)
279 }
280 return parts.joined(separator: ". ")
281 }
282
283 private var sharedPlayersAnnouncement: String? {
284 let names = roster.entries
285 .filter { !$0.isLocal }
286 .map(\.name)
287 .filter { !$0.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }
288 guard !names.isEmpty else { return nil }
289 return "Shared with \(Self.formattedList(names))"
290 }
291
292 private static func formattedList(_ items: [String]) -> String {
293 switch items.count {
294 case 0:
295 return ""
296 case 1:
297 return items[0]
298 case 2:
299 return "\(items[0]) and \(items[1])"
300 default:
301 let prefix = items.dropLast().joined(separator: ", ")
302 return "\(prefix), and \(items[items.count - 1])"
303 }
304 }
305
306 private var phoneLayout: some View {
307 puzzleArea()
308
309
310
311
312 .safeAreaInset(edge: .bottom, spacing: 0) {
313 controlsArea(showClueBar: true)
314 }
315 }
316
317 private var landscapePadLayout: some View {
318 VStack(spacing: 0) {
319 HStack(spacing: 0) {
320 VStack(spacing: 0) {
321 if !isSolved {
322 PuzzleScoreboard(
323 session: session,
324 roster: roster,
325 onNudge: onNudge,
326 nudgeReadyAt: nudgeReadyAt
327 )
328
329 Divider()
330 }
331
332 ClueList(session: session, presentation: .sidebar, replayFrame: replay.frame)
333 }
334 .frame(minWidth: 300, idealWidth: 360, maxWidth: 420)
335 .background(Color(.secondarySystemBackground))
336
337 Divider()
338 .ignoresSafeArea(edges: .top)
339
340 puzzleArea(bottomInset: 12)
341 .frame(maxWidth: .infinity, maxHeight: .infinity)
342 }
343 .frame(maxWidth: .infinity, maxHeight: .infinity)
344
345 controlsArea(showClueBar: false)
346 }
347 }
348
349 private var portraitPadLayout: some View {
350 VStack(spacing: 0) {
351 WeightedVStack(weights: [3, 1]) {
352 puzzleArea(bottomInset: 12)
353 .frame(maxWidth: .infinity, maxHeight: .infinity)
354
355 VStack(spacing: 0) {
356 Divider()
357
358 HStack(alignment: .top, spacing: 0) {
359 if !isSolved {
360 PuzzleScoreboard(
361 session: session,
362 roster: roster,
363 onNudge: onNudge,
364 nudgeReadyAt: nudgeReadyAt
365 )
366 .frame(minWidth: 240, idealWidth: 280, maxWidth: 320)
367
368 Divider()
369 }
370
371 ClueList(session: session, presentation: .sidebar, replayFrame: replay.frame)
372 .frame(maxWidth: .infinity, maxHeight: .infinity)
373 }
374 .background(Color(.secondarySystemBackground))
375 }
376 }
377 .frame(maxWidth: .infinity, maxHeight: .infinity)
378
379 controlsArea(showClueBar: false)
380 }
381 }
382
383 private func updateLayoutTrait(for size: CGSize, force: Bool = false) {
384
385
386
387
388
389
390 guard force || UIApplication.shared.applicationState == .active else {
391 return
392 }
393 let newLayout: PadLayout?
394 if UIDevice.current.userInterfaceIdiom == .pad {
395 if Self.activeWindowSceneOrientation?.isLandscape == true {
396 newLayout = .landscape
397 } else {
398 newLayout = size.width > size.height ? .landscape : .portrait
399 }
400 } else {
401 newLayout = nil
402 }
403
404
405 if newLayout != padLayout {
406 padLayout = newLayout
407 }
408 }
409
410 private static var activeWindowSceneOrientation: UIInterfaceOrientation? {
411 UIApplication.shared.connectedScenes
412 .compactMap { $0 as? UIWindowScene }
413 .first { $0.activationState == .foregroundActive }?
414 .interfaceOrientation
415 }
416
417 private func performResign() {
418 do {
419 try onResign?()
420 dismiss()
421 } catch {
422 destructiveActionError = String(describing: error)
423 }
424 }
425
426 private func performDelete() {
427 do {
428 try onDelete?()
429 dismiss()
430 } catch {
431 destructiveActionError = String(describing: error)
432 }
433 }
434
435 private func handleCompletionEvent(_ event: PlayerSession.CompletionEvent) {
436 switch (event.origin, event.state) {
437 case (_, .incomplete):
438 break
439 case (.observed, .filledWithErrors):
440
441 break
442 case (.local, .filledWithErrors):
443 showErrorsAlert = true
444 case (.local, .solved):
445 guard !hasSolved else { return }
446 hasSolved = true
447 if session.isPencilMode {
448 session.togglePencil()
449 }
450 Task { @MainActor in
451 onComplete?(true)
452 }
453 case (.observed, .solved):
454 guard !hasSolved else { return }
455 hasSolved = true
456 onComplete?(false)
457 }
458 }
459
460 private func puzzleArea(bottomInset: CGFloat = 0) -> some View {
461 ZStack {
462 VStack(spacing: 4) {
463 PuzzleHeader(
464 session: session,
465 roster: roster,
466 title: titleParts.title,
467 subtitle: titleParts.subtitle,
468 showsScoreboard: effectivePadLayout == nil,
469 shouldAutoRevealScoreboard: shouldAutoRevealScoreboard,
470 gameID: session.mutator.gameID,
471 isEngagementLive: engagementStatus?.isLive(gameID: session.mutator.gameID) == true,
472 onNudge: onNudge,
473 nudgeReadyAt: nudgeReadyAt,
474 isArmed: isArmed
475 )
476 GridView(
477 session: session,
478 roster: roster,
479 revealConfirmation: revealConfirmation,
480 showsSharedAnnotations: session.mutator.showsPlayerAttribution,
481 showsPeerCursors: !isSolved,
482 replayFrame: replay.frame
483 )
484 }
485 .frame(maxWidth: .infinity, maxHeight: .infinity)
486 .padding(.top, -8)
487
488
489
490 .padding(.bottom, bottomInset)
491
492 if session.isRebusActive {
493 Color.black.opacity(0.35)
494
495
496
497 .ignoresSafeArea(edges: [.top, .bottom])
498 .contentShape(Rectangle())
499 .onTapGesture {
500 session.commitRebus()
501 }
502
503
504
505
506 RebusModal(text: $session.rebusBuffer, isFocused: $isRebusFieldFocused) {
507 session.commitRebus()
508 }
509 .padding(.horizontal)
510 }
511 }
512 }
513
514 private func controlsArea(showClueBar: Bool) -> some View {
515 VStack(spacing: 0) {
516 if showClueBar {
517 ClueBarSlot(session: session, replayFrame: replay.frame)
518 }
519 controlsPanel
520 .frame(height: controlsPanelHeight)
521 }
522 }
523
524 private var controlsPanel: some View {
525 ZStack(alignment: .top) {
526 if isSolved {
527 ControlsView(height: controlsPanelHeight) {
528 SuccessPanel(
529 session: session,
530 roster: roster,
531 replay: replay,
532 loadReplay: loadReplay
533 )
534 }
535 .transition(.move(edge: .bottom))
536 } else if showsCustomKeyboard {
537 ControlsView(height: controlsPanelHeight) {
538 KeyboardView(session: session, showsNavigationKeys: effectivePadLayout != nil)
539 .opacity(isInputBlocked ? 0.4 : 1)
540 .allowsHitTesting(!isInputBlocked)
541 .animation(.easeInOut(duration: 0.3), value: isInputBlocked)
542 }
543 .transition(.move(edge: .bottom))
544 }
545 }
546 .frame(height: controlsPanelHeight, alignment: .top)
547 .background {
548 Color(.systemGroupedBackground)
549 .ignoresSafeArea(edges: .bottom)
550 }
551 .overlay(alignment: .top) {
552 if controlsPanelHeight > 0 {
553 Rectangle()
554 .fill(Color(.opaqueSeparator))
555 .frame(height: 0.5)
556 }
557 }
558 .animation(.easeOut(duration: 0.25), value: isSolved)
559 }
560
561 private var controlsPanelHeight: CGFloat {
562 isSolved || showsCustomKeyboard ? KeyboardView.standardHeight : 0
563 }
564
565 private var showsCustomKeyboard: Bool {
566 !inputMonitor.isConnected
567 }
568
569 private func handleHardwareKeyboardEvent(_ event: HardwareKeyboardEvent) -> Bool {
570
571
572
573
574 let isEntryBlocked = isSolved || isInputBlocked
575
576
577
578
579
580 switch event.keyCode {
581 case .keyboardA, .keyboardB, .keyboardC, .keyboardD, .keyboardE,
582 .keyboardF, .keyboardG, .keyboardH, .keyboardI, .keyboardJ,
583 .keyboardK, .keyboardL, .keyboardM, .keyboardN, .keyboardO,
584 .keyboardP, .keyboardQ, .keyboardR, .keyboardS, .keyboardT,
585 .keyboardU, .keyboardV, .keyboardW, .keyboardX, .keyboardY,
586 .keyboardZ,
587 .keyboard0, .keyboard1, .keyboard2, .keyboard3, .keyboard4,
588 .keyboard5, .keyboard6, .keyboard7, .keyboard8, .keyboard9:
589 guard !isEntryBlocked,
590 !event.modifierFlags.contains(.command),
591 !event.modifierFlags.contains(.control),
592 !event.modifierFlags.contains(.alternate),
593 let character = hardwareKeyboardCharacter(from: event) else {
594 return false
595 }
596 if session.isRebusActive {
597 session.appendRebusLetter(character)
598 } else {
599 session.enter(character)
600 }
601 return true
602
603 case .keyboardDeleteOrBackspace, .keyboardDeleteForward:
604 guard !isEntryBlocked else { return false }
605 if session.isRebusActive {
606 session.deleteRebusLetter()
607 } else {
608 session.deleteBackward()
609 }
610 return true
611
612 case .keyboardLeftArrow:
613 guard !session.isRebusActive else { return false }
614 if event.modifierFlags.contains(.command) {
615 session.goToPreviousWord()
616 return true
617 }
618 moveWithHardwareArrow(direction: .across) {
619 session.goToPreviousLetter()
620 }
621 return true
622
623 case .keyboardRightArrow:
624 guard !session.isRebusActive else { return false }
625 if event.modifierFlags.contains(.command) {
626 session.goToNextWord()
627 return true
628 }
629 moveWithHardwareArrow(direction: .across) {
630 session.goToNextLetter()
631 }
632 return true
633
634 case .keyboardUpArrow:
635 guard !session.isRebusActive else { return false }
636 moveWithHardwareArrow(direction: .down) {
637 session.goToPreviousLetter()
638 }
639 return true
640
641 case .keyboardDownArrow:
642 guard !session.isRebusActive else { return false }
643 moveWithHardwareArrow(direction: .down) {
644 session.goToNextLetter()
645 }
646 return true
647
648 case .keyboardTab:
649 guard !session.isRebusActive else { return false }
650 if event.modifierFlags.contains(.shift) {
651 session.goToPreviousClue()
652 } else {
653 session.goToNextClue()
654 }
655 return true
656
657 case .keyboardSpacebar:
658 guard !session.isRebusActive else { return false }
659 session.toggleDirection()
660 return true
661
662 case .keyboardReturnOrEnter:
663 if session.isRebusActive {
664 session.commitRebus()
665 } else {
666 session.toggleDirection()
667 }
668 return true
669
670 case .keyboardEscape:
671 if session.isRebusActive {
672 session.commitRebus()
673 return true
674 }
675 return false
676
677 default:
678 return false
679 }
680 }
681
682 private func hardwareKeyboardCharacter(from event: HardwareKeyboardEvent) -> String? {
683 let scalars = event.charactersIgnoringModifiers.unicodeScalars
684 guard scalars.count == 1, let scalar = scalars.first else { return nil }
685
686 switch scalar.value {
687 case 65...90, 97...122:
688 return String(Character(scalar)).uppercased()
689 case 48...57:
690 return String(Character(scalar))
691 default:
692 return nil
693 }
694 }
695
696 private func moveWithHardwareArrow(direction: Puzzle.Direction, move: () -> Void) {
697 if session.direction != direction {
698 let previousDirection = session.direction
699 session.setDirection(direction)
700 if session.direction != previousDirection {
701 return
702 }
703 }
704
705 move()
706 }
707
708 private func leaveSharedGame() async {
709 guard let shareController else { return }
710 do {
711 try await shareController.leaveShare(gameID: session.mutator.gameID)
712 dismiss()
713 } catch {
714 leaveError = String(describing: error)
715 }
716 }
717}
718
719private struct RebusModal: View {
720 @Binding var text: String
721 var isFocused: FocusState<Bool>.Binding
722 let onCommit: () -> Void
723
724 var body: some View {
725 styledField
726 .accessibilityLabel("Rebus entry")
727 .accessibilityValue(accessibilityValue)
728 .accessibilityHint("Enter the full text for this square")
729 .accessibilityAction(.default, onCommit)
730 }
731
732 private var styledField: some View {
733
734
735
736 TextField("", text: $text)
737 .focused(isFocused)
738 .keyboardType(.asciiCapable)
739 .textInputAutocapitalization(.characters)
740
741
742
743
744 .onChange(of: text) { _, newValue in
745 let upper = newValue.uppercased()
746 if upper != newValue { text = upper }
747 }
748 .autocorrectionDisabled()
749 .submitLabel(.done)
750 .onSubmit(onCommit)
751 .multilineTextAlignment(.center)
752 .font(.system(size: 32, weight: .semibold, design: .rounded))
753 .foregroundStyle(.primary)
754 .frame(maxWidth: .infinity, minHeight: 56)
755 .padding(.horizontal, 16)
756 .background(Color(.systemBackground))
757 .clipShape(RoundedRectangle(cornerRadius: 10, style: .continuous))
758 .padding(20)
759 .frame(maxWidth: .infinity)
760 .background(Color(.secondarySystemBackground))
761 .clipShape(RoundedRectangle(cornerRadius: 14, style: .continuous))
762 }
763
764 private var accessibilityValue: String {
765 text.isEmpty ? "Empty" : text
766 }
767}
768
769private struct ControlsView<Content: View>: View {
770 let height: CGFloat
771 @ViewBuilder var content: () -> Content
772
773 var body: some View {
774 content()
775 .frame(height: height)
776 }
777}