Ask for a tip at good moments, say what TABOR costs, and thank supporters on their cards

The servers aren't free, but the only asks were a card on ME at 25 catches that led to
Settings, and the tips at the top of Settings. Now a short sheet comes up after the reveal of
a catch worth celebrating: the first legendary, a new badge, or the 50th, 150th or 500th
catch. It waits for the reveal and any badge toasts to go, says what TABOR costs to run
(about 55 zł a month), and offers the three tips. It asks three times at most, two weeks
apart, and never once someone has tipped (a real tip, so debug builds still get asked). ME's
card opens the same sheet and counts as one of the three. Settings says the same cost line.

A tip now also puts a gold rim and a SUPPORTER mark on the cards you share (catch, badge and
stats), so the thank-you goes wherever they post them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: TheFilipcom4607

Tabor/App/TaborApp.swift

@@ -88,8 +88,35 @@ final class Router {
     func revealGone() {
         landing = pendingLanding
         pendingLanding = nil
+        revealOpen = false
+        revealClosed = Date()
     }
 
+    /// A reveal is on screen: nothing else may be presented over the app meanwhile.
+    private(set) var revealOpen = false
+    /// When the last one went, so a badge it earned can still count as its moment.
+    private(set) var revealClosed: Date?
+
+    func revealShown() { revealOpen = true }
+
+    /// A catch worth asking for a tip on (`SupportAsk`), held until the reveal and any badge
+    /// toasts have gone. The first reason wins.
+    private(set) var supportPending: SupportAsk.Reason?
+    /// The tip sheet, presented from RootView so it's never on top of the reveal.
+    var supportSheet: SupportAsk.Reason?
+
+    func askForSupport(_ reason: SupportAsk.Reason) {
+        if supportPending == nil { supportPending = reason }
+    }
+
+    /// From a badge earned by a catch just made (the badges are worked out once it settles).
+    func badgeEarned() {
+        guard let revealClosed, Date().timeIntervalSince(revealClosed) < 30 else { return }
+        askForSupport(.newBadge)
+    }
+
+    func supportAsked() { supportPending = nil }
+
     /// Its vehicles on HUNT's map. The filter is already set; the book keeps its place.
     func showOnHunt(_ modelId: String) {
         huntModel = modelId
@@ -207,6 +234,21 @@ struct RootView: View {
                 .transition(.move(edge: .top).combined(with: .opacity))
             }
         }
+        // The tip sheet, once the reveal and the badge toasts are out of the way: a catch's
+        // badges arrive a couple of seconds after it settles, so give them time to start.
+        .task(id: router.supportPending) {
+            guard let reason = router.supportPending else { return }
+            try? await Task.sleep(for: .seconds(3.5))
+            for _ in 0..<40 where router.revealOpen || badges.busy {
+                try? await Task.sleep(for: .milliseconds(500))
+            }
+            guard !Task.isCancelled else { return }
+            router.supportAsked()
+            guard !router.revealOpen, !badges.busy, SupportAsks.due else { return }
+            SupportAsks.record()
+            router.supportSheet = reason
+        }
+        .sheet(item: $router.supportSheet) { reason in TipSheet(reason: reason) }
         .task { await FleetUpdater.checkIfDue() }
         .task { TipJar.shared.start() }
         .task { await Task.detached(priority: .background) { StorageUsage.sweep() }.value }
@@ -224,7 +266,7 @@ struct RootView: View {
             guard await settled() else { return }
             let earned = await Task.detached(priority: .utility) { Achievements.evaluate(records, catalog: catalog) }.value
             guard !Task.isCancelled else { return }
-            badges.update(earned)
+            if badges.update(earned) { router.badgeEarned() }
             await WeatherService.backfill(sightings, context: context)
         }
         // Refresh the Home / Lock Screen widgets whenever what they show could have changed.

Tabor/Core/SupportAsk.swift

@@ -0,0 +1,38 @@
+import Foundation
+
+/// When TABOR asks for a tip: right after a catch worth celebrating, never more than three
+/// times, and two weeks apart at least, so a supporter-to-be gets asked at a happy moment and
+/// everyone else is left alone.
+public enum SupportAsk {
+    public enum Reason: Hashable, Sendable {
+        case firstLegendary
+        case newBadge
+        /// The catch that reached this many.
+        case milestone(Int)
+        /// The card on ME.
+        case meCard
+    }
+
+    public static let milestones = [50, 150, 500]
+    public static let maxAsks = 3
+    public static let gap: TimeInterval = 14 * 24 * 3600
+
+    /// What makes this catch worth asking on, if anything. `catches` leave second cars out,
+    /// as the stats do; the other vehicles in a shot count.
+    public static func reason(catchesBefore: Int, catchesAfter: Int, firstLegendary: Bool) -> Reason? {
+        if firstLegendary { return .firstLegendary }
+        return milestones.first { catchesBefore < $0 && $0 <= catchesAfter }.map(Reason.milestone)
+    }
+
+    /// The first legendary: one in this catch, none in the book before it.
+    public static func isFirstLegendary(before: CollectionStats, caught modelIds: [String], catalog: FleetCatalog) -> Bool {
+        let legendary = { (id: String) in catalog.model(id: id)?.tier == .legendary }
+        return modelIds.contains(where: legendary) && !before.vehicles.contains { legendary($0.modelId) }
+    }
+
+    /// `tipped` is a real tip, not debug builds' stand-in supporter, so they still get asked.
+    public static func due(asks: Int, lastAsked: Date?, now: Date, tipped: Bool) -> Bool {
+        guard !tipped, asks < maxAsks else { return false }
+        return lastAsked.map { now.timeIntervalSince($0) >= gap } ?? true
+    }
+}

Tabor/Resources/Localizable.xcstrings

@@ -1,6 +1,76 @@
 {
   "sourceLanguage": "en",
   "strings": {
+    "TABOR costs about 55 zł a month to run: the server behind HUNT's live map and Apple's developer fee. It's free with no ads, so tips are what keep it going.": {
+      "localizations": {
+        "pl": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Utrzymanie TABORU kosztuje około 55 zł miesięcznie: serwer, z którego HUNT bierze mapę na żywo, i opłata deweloperska dla Apple. Aplikacja jest darmowa i bez reklam, więc to napiwki pozwalają jej działać."
+          }
+        }
+      }
+    },
+    "Any tip puts a heart next to ME, unlocks three extra app icons and a gold rim on the cards you share.": {
+      "localizations": {
+        "pl": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Każdy napiwek dodaje serduszko przy ME, odblokowuje trzy dodatkowe ikony aplikacji i złotą ramkę na kartach, które udostępniasz."
+          }
+        }
+      }
+    },
+    "Badges and everything else stay free.": {
+      "localizations": {
+        "pl": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Odznaki i cała reszta zostają za darmo."
+          }
+        }
+      }
+    },
+    "Keep TABOR going": {
+      "localizations": {
+        "pl": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Pomóż utrzymać TABOR"
+          }
+        }
+      }
+    },
+    "YOUR FIRST LEGENDARY": {
+      "localizations": {
+        "pl": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "TWÓJ PIERWSZY LEGENDARNY"
+          }
+        }
+      }
+    },
+    "NEW BADGE": {
+      "localizations": {
+        "pl": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "NOWA ODZNAKA"
+          }
+        }
+      }
+    },
+    "NOT NOW": {
+      "localizations": {
+        "pl": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "NIE TERAZ"
+          }
+        }
+      }
+    },
     "Export as spreadsheet (CSV)": {
       "localizations": {
         "pl": {

Tabor/Screens/Badges.swift

@@ -556,21 +556,27 @@ final class BadgeTracker {
     private var showing = false
     private static let key = "badgeLevelsSeen"
 
-    func update(_ badges: [Achievement]) {
+    /// A toast is up or waiting.
+    var busy: Bool { showing || current != nil || !queue.isEmpty }
+
+    /// Queues a toast for anything newly earned; true if there was any.
+    @discardableResult
+    func update(_ badges: [Achievement]) -> Bool {
         let defaults = UserDefaults.standard
         let now = Dictionary(badges.map { ($0.id, $0.level) }, uniquingKeysWith: max)
         guard let seen = defaults.dictionary(forKey: Self.key) as? [String: Int] else {
             // First launch with badges: what's already earned arrives quietly.
             defaults.set(now, forKey: Self.key)
-            return
+            return false
         }
         let fresh = badges.filter { $0.level > (seen[$0.id] ?? 0) }
         // Remember the best level ever reached, so deleting and re-adding a catch doesn't replay it.
         defaults.set(seen.merging(now, uniquingKeysWith: max), forKey: Self.key)
-        guard !fresh.isEmpty else { return }
+        guard !fresh.isEmpty else { return false }
         let best = fresh.sorted { ($0.secret ? 1 : 0, $0.level) > ($1.secret ? 1 : 0, $1.level) }
         queue += best.count > 3 ? [Unlock(badge: best[0], others: best.count - 1)] : best.map { Unlock(badge: $0) }
         if !showing { Task { await playQueue() } }
+        return true
     }
 
     func dismiss() {

Tabor/Screens/MeView.swift

@@ -92,9 +92,11 @@ struct MeView: View {
                     }
                     .padding(.top, 18)
                     .padding(.horizontal, 22)
-                } else if !supportTipSeen, !TipJar.shared.tipped, sightings.count >= SupportTip.afterCatches {
+                } else if !supportTipSeen, !TipJar.shared.tipped, SupportAsks.count < SupportAsk.maxAsks,
+                          sightings.count >= SupportTip.afterCatches {
                     TipCard(icon: "heart.fill", kicker: "ENJOYING TABOR?", title: "Consider supporting it with a tip") {
-                        showSettings = true
+                        SupportAsks.record()
+                        router.supportSheet = .meCard
                         supportTipSeen = true
                     } dismiss: {
                         withAnimation(.snappy) { supportTipSeen = true }

Tabor/Screens/RevealView.swift

@@ -341,6 +341,7 @@ struct RevealView: View {
         }
         .onChange(of: draft.partner) { _, _ in refreshAlso() }
         .animation(.spring(response: 0.45, dampingFraction: 0.6), value: draft.wrap)
+        .onAppear { router.revealShown() }
         // Only now may the book scroll to the catch: CATCH (and this cover with it) goes as the
         // tab switches, so the cover's own onDismiss never runs.
         .onDisappear { router.revealGone() }
@@ -1035,6 +1036,13 @@ struct RevealView: View {
             context.assign(number: number, to: model.id, existing: manual)
         }
         try? context.save()
+        // A moment worth asking for a tip on; the sheet waits until the reveal has gone.
+        let catches = (try? context.fetchCount(FetchDescriptor<Sighting>(predicate: #Predicate { $0.pairedWith == nil }))) ?? 0
+        let added = cars.filter { $0.pairedWith == nil }.count
+        let firstLegendary = SupportAsk.isFirstLegendary(before: draft.book.stats, caught: cars.map(\.modelId), catalog: catalog)
+        if let reason = SupportAsk.reason(catchesBefore: catches - added, catchesAfter: catches, firstLegendary: firstLegendary) {
+            router.askForSupport(reason)
+        }
         // Shrinking a full-size shot takes a moment: off the main thread, then each sighting
         // points at its own small copy (HEIC, so a new name) and the full-size one goes.
         let files = cars.map(\.photoFile)

Tabor/Screens/ShareCard.swift

@@ -59,11 +59,12 @@ struct ShareCard: View {
         let accent = wrap != nil ? Palette.foilInk : tier == .common ? Palette.yellow : tier.color
 
         VStack(alignment: .leading, spacing: 0) {
-            HStack {
+            HStack(spacing: 8) {
                 Text("TABOR")
                     .font(TaborFont.grotesk(15, 700))
                     .em(0.02, size: 15)
                     .foregroundStyle(Palette.ink)
+                SupporterMark()
                 Spacer()
                 Mono("CAUGHT · \(Self.day.string(from: sighting.date).uppercased())", size: 9.5, spacing: 0.14,
                      color: accent)
@@ -133,6 +134,7 @@ struct ShareCard: View {
                 ], center: .init(x: 0.5, y: 0.42), startRadius: 8, endRadius: 260)
             }
         }
+        .supporterRim()
         .environment(\.colorScheme, .dark)
     }
 
@@ -289,11 +291,12 @@ struct BadgeShareCard: View {
         let medal = badge.medal
 
         VStack(spacing: 0) {
-            HStack {
+            HStack(spacing: 8) {
                 Text("TABOR")
                     .font(TaborFont.grotesk(15, 700))
                     .em(0.02, size: 15)
                     .foregroundStyle(Palette.ink)
+                SupporterMark()
                 Spacer()
                 Mono(badge.kicker, size: 9.5, spacing: 0.14, color: medal.ink)
             }
@@ -346,6 +349,7 @@ struct BadgeShareCard: View {
                 ], center: .init(x: 0.5, y: 0.22), startRadius: 8, endRadius: 280)
             }
         }
+        .supporterRim()
         .environment(\.colorScheme, .dark)
     }
 
@@ -376,3 +380,34 @@ struct BadgeShareCard: View {
         }
     }
 }
+
+/// Supporters' share cards: a gold edge, and ♥ SUPPORTER by the wordmark, a thank-you that
+/// travels with what they share.
+struct SupporterMark: View {
+    var body: some View {
+        if TipJar.shared.isSupporter {
+            HStack(spacing: 3) {
+                Image(systemName: "heart.fill").font(.system(size: 7.5, weight: .bold))
+                Mono("SUPPORTER", size: 8.5, weight: 700, spacing: 0.12, color: Palette.yellow)
+            }
+            .foregroundStyle(Palette.yellow)
+            .padding(.horizontal, 6)
+            .padding(.vertical, 2.5)
+            .background(Palette.yellow.opacity(0.14), in: Capsule())
+            .fixedSize()
+        }
+    }
+}
+
+extension View {
+    func supporterRim() -> some View {
+        overlay {
+            if TipJar.shared.isSupporter {
+                Rectangle().strokeBorder(
+                    LinearGradient(colors: [Palette.goldWash, Palette.yellow, Palette.brass, Palette.yellow, Palette.goldWash],
+                                   startPoint: .topLeading, endPoint: .bottomTrailing),
+                    lineWidth: 5)
+            }
+        }
+    }
+}

Tabor/Screens/StatsView.swift

@@ -954,8 +954,9 @@ private struct StatsShareCard: View {
         let s = stats
         let rarest = s.records.rarest.flatMap { r in catalog.model(id: r.modelId).map { (r, $0) } }
         VStack(alignment: .leading, spacing: 0) {
-            HStack {
+            HStack(spacing: 8) {
                 Text("TABOR").font(TaborFont.mono(13, 700)).em(0.2, size: 13)
+                SupporterMark()
                 Spacer()
                 Mono(dateLine, size: 10.5, color: Palette.sub)
             }
@@ -993,6 +994,7 @@ private struct StatsShareCard: View {
         .padding(.bottom, 22)
         .frame(width: 360, height: 640, alignment: .topLeading)
         .background(Palette.bg)
+        .supporterRim()
         .environment(\.colorScheme, .dark)
     }