Adding Game Center to a Rork Max Game: Authentication, Leaderboards, Achievements, and Living with Score Tampering

Authentication: the authenticateHandler Etiquette

The entry point to GameKit is authenticating GKLocalPlayer. There is an etiquette to it, and skipping it costs you in UX or in App Review.

This is the minimal setup: register the handler once at launch, then receive state changes from there on.

import GameKit
 
final class GameCenterManager {
    static let shared = GameCenterManager()
    private(set) var isAuthenticated = false
 
    func authenticate(presenting rootVC: UIViewController) {
        GKLocalPlayer.local.authenticateHandler = { [weak self] viewController, error in
            if let viewController {
                // Only when sign-in is needed, present Apple's standard sign-in screen
                rootVC.present(viewController, animated: true)
                return
            }
            if let error {
                // Authentication failed. Keep the game itself playable.
                print("Game Center authentication failed: \(error.localizedDescription)")
                self?.isAuthenticated = false
                return
            }
            self?.isAuthenticated = GKLocalPlayer.local.isAuthenticated
        }
    }
}

Three things I learned by implementing this.

First, set authenticateHandler on every launch. Even for an already-authenticated player, re-evaluation can happen — for example when returning from the background — so "registered permanently" is the correct shape.

Second, the sign-in view controller is only handed to you while the player is signed out. Once a player cancels it, it will not be presented again automatically. Quietly documenting the path back — signing in via the Game Center section of the Settings app — saves you support email later.

Third, and most important: keep the game playable when authentication fails. Locking the game behind a forced Game Center sign-in is bad both as an experience and from an App Review standpoint. Disable the ranking features silently and let the game itself run normally.

Submitting Scores and Showing the Leaderboard

Score submission is close to a one-liner. This code sends the final score at game over.

func submit(score: Int, to leaderboardID: String) {
    guard isAuthenticated else { return }
    GKLeaderboard.submitScore(
        score,
        context: 0,
        player: GKLocalPlayer.local,
        leaderboardIDs: [leaderboardID]
    ) { error in
        if let error {
            print("Score submission failed: \(error.localizedDescription)")
        }
    }
}

Submission mostly fails when the device is offline. submitScore has no built-in retry, so stash failed scores in UserDefaults and resend on next launch or reconnection. You only need to keep the best pending score, so the whole mechanism fits in a few dozen lines.

For an entry point into the rankings, GKAccessPoint gives you Apple's official floating button in a screen corner.

GKAccessPoint.shared.location = .topLeading
GKAccessPoint.shared.showHighlights = true
GKAccessPoint.shared.isActive = true

I recommend hiding it during gameplay, though. Sitting in the corner of the play area, it invites accidental taps — I keep it active only on the title and result screens.

To open the leaderboard on demand, use GKGameCenterViewController.

func showLeaderboard(from rootVC: UIViewController, leaderboardID: String) {
    let vc = GKGameCenterViewController(
        leaderboardID: leaderboardID,
        playerScope: .global,
        timeScope: .allTime
    )
    vc.gameCenterDelegate = rootVC as? GKGameCenterControllerDelegate
    rootVC.present(vc, animated: true)
}

If you forget to call dismiss inside the delegate's gameCenterViewControllerDidFinish, you get a screen whose close button does nothing. Everyone hits this on the first test run, so I am writing it down here first.

Achievements Last Longer When Used for Accumulation

Achievements report percentComplete from 0 to 100. What makes them pleasant is that they work for cumulative progress, not just one-shot unlocks.

func reportAchievement(id: String, percent: Double) {
    guard isAuthenticated else { return }
    let achievement = GKAchievement(identifier: id)
    achievement.percentComplete = min(percent, 100)
    achievement.showsCompletionBanner = true
    GKAchievement.report([achievement]) { error in
        if let error {
            print("Achievement report failed: \(error.localizedDescription)")
        }
    }
}

For something like "clear 100 stages in total," convert the running count to a percentage on each clear and you get an achievement with a progress bar for free. Re-reporting the same value is harmless, but avoid designs that report every frame — send only when the value changes.

Living with Score Tampering

This is the section I most wanted to write. Game Center scores are client-reported, and no server-side validation mechanism is provided. Design must therefore start from the premise that tampering cannot be fully prevented.

Even so, there are mitigations that realistically work at indie scale.

1. Clip to the theoretical maximum: compute the highest score physically reachable in your game and reject anything above it before submission. This alone removes the "9,999,999,999 points" class of junk from your leaderboard
2. Bury the submission call inside game logic: submitting from deep inside result processing, rather than exposing it to the UI layer, raises the bar against casual modification
3. Pack metadata into context: folding play time or stage number into submitScore's context gives you forensic material for analyzing anomalies later
4. Glance at the top ranks regularly: a weekly look at the distribution of the top entries is enough to notice contamination quickly

If you need more strength than that, the architecture becomes a custom API alongside Game Center, verified with App Attest. I covered server-side verification of device and app integrity in App Attest and Play Integrity server validation.

The important thing is not losing sight of the goal. What you are protecting is the experience of honest players — not winning an arms race against cheaters. Clipping plus periodic monitoring keeps a leaderboard feeling healthy to the people who matter.

What Shipping It Taught Me

An observation from one small game: day-one retention improved from roughly 31% to 36% — about five points — after the leaderboard opened. Sessions that opened the rankings via GKAccessPoint accounted for about 12% of the total. Once the result screen started showing a single line — "120 points to reach the top 10" — consecutive play sessions visibly increased. A rank, by itself, is a reason to come back.

If you want more re-entry paths from the home screen, pairing this with a ControlWidget launch-path design works well. On the game side, Metal 3D game generation makes a good companion read.

Start with a single leaderboard and nothing else. Achievements and custom UI can wait until you can see players actually opening the rankings. With the code in this article, the minimal setup is a same-day job.

Thank you for reading. I hope your leaderboards fill up with honest scores.