Take Flight

Authenticates the local player with Game Center on launch and reports achievement completions with a native banner.

// Call once at app start or main menu.
@MainActor
func authenticateLocalPlayer(presentingViewController: UIViewController?) async {
    let localPlayer = GKLocalPlayer.local
    localPlayer.authenticateHandler = { viewController, error in
        if let viewController, let presentingViewController {
            presentingViewController.present(viewController, animated: true)
            return
        }
        
        if let error {
            print("Game Center auth error: \(error.localizedDescription)")
            return
        }
        
        self.isAuthenticated = localPlayer.isAuthenticated
    }
}

// Set an achievement to 100% immediately.
func completeAchievement(id: String, showBanner: Bool = true) async {
    guard GKLocalPlayer.local.isAuthenticated else { return }
    
    let achievement = GKAchievement(identifier: id)
    achievement.percentComplete = 100
    achievement.showsCompletionBanner = showBanner
    
    do {
        try await GKAchievement.report([achievement])
    } catch {
        print("Achievement report error: \(error.localizedDescription)")
    }
}

A SwiftUI joystick built with DragGesture that clamps input to a circle radius and writes a normalized CGPoint velocity into the shared ViewModel for SpriteKit to read each frame.

// Custom Joystick
ZStack {
    Circle() // Background
        .fill(.white.opacity(0.3))
        
    
    Circle() // Thumbstick
        .fill(.white.opacity(0.8))
        .frame(width: radius, height: radius)
        .offset(x: fingerLocation.x, y: fingerLocation.y)
        .gesture(
            DragGesture(minimumDistance: 0)
                .onChanged { value in
                    isDragging = true

                    let dx = value.translation.width
                    let dy = value.translation.height

                    // Clamp to joystick radius
                    let distance = hypot(dx, dy)
                    let angle = atan2(dy, dx)
                    let clamped = min(distance, radius)

                    // Knob position inside the base circle
                    let knob = CGPoint(x: cos(angle) * clamped, y: sin(angle) * clamped)
                    fingerLocation = knob

                    // Normalize and flip Y so up is positive in SpriteKit
                    viewModel.joystickVelocity = CGPoint(x: knob.x / radius, y: -knob.y / radius)
                }
                .onEnded  { _ in
                    isDragging = false
                    fingerLocation = .zero
                    viewModel.joystickVelocity = .zero
                }
        )
    
    
}
.frame(width: radius * 2, height: radius * 2)
.contentShape(Circle())

A RunState enum drives tutorial, active, and game-over phases. Contextual onboarding sheets fire at the right moments and dismiss cleanly into the active run.

if viewModel?.tutorialIsOn == true, viewModel?.inventoryFullOnce == false {
    viewModel?.showMainGameInstructions(type: .nestBuilding)
    viewModel?.inventoryFullOnce = true
}

enum RunState {
    case tutorial
    case active
    case gameOver
}

@Published private(set) var state: RunState = .tutorial

func completeTutorial() {
    state = .active
    showTutorialOverlay = false
}

func restartToTutorial() {
    state = .tutorial
    showTutorialOverlay = true
}

struct MainOnboardingView: View {
    @ObservedObject var viewModel: MainGameView.ViewModel
    @Environment(\.dismiss) var dismiss
    let type: MainGameView.ViewModel.InstructionType

    var body: some View {
        VStack(spacing: 16) {
            Text("Tutorial").font(.system(.title, design: .rounded)).bold()
            Text(viewModel.mainInstructionText(for: type))
                .multilineTextAlignment(.center)

            let resources = viewModel.mainInstructionImage(for: type)
            if let imageName = resources.first {
                Image(imageName).resizable().scaledToFit()
            }

            Button("Start") { dismiss() }
                .buttonStyle(.borderedProminent)
        }
        .presentationDetents([.medium])
    }
}

The SpriteKit update loop clamps delta time to a safe range, ticks down hunger on an accumulator, persists player position every second, then drives movement and camera follow.

override func update(_ currentTime: TimeInterval) {
    handleKeyboardMapInput()
    if viewModel?.isMapMode == true { return }

    viewModel?.currentMessage = ""

    if lastUpdateTime == 0 { lastUpdateTime = currentTime }
    let rawDelta: CGFloat = CGFloat(currentTime - lastUpdateTime)
    let deltaTime = min(max(rawDelta, 1.0/120.0), 1.0/30.0)
    lastUpdateTime = currentTime

    positionPersistAccumulator += deltaTime
    if positionPersistAccumulator >= 1.0 {
        positionPersistAccumulator = 0
        if let player = childNode(withName: "userBird") {
            viewModel?.savedPlayerPosition = player.position
        }
        viewModel?.savedCameraPosition = cameraNode.position
        viewModel?.saveState()
    }

    healthAccumulator += deltaTime
    if healthAccumulator >= 35.0 {
        healthAccumulator = 0
        if let current = viewModel?.hunger, current > 0 { viewModel?.hunger = current - 1 }
    }

    guard let player = childNode(withName: "userBird") else { return }

    updatePlayerPosition(deltaTime: deltaTime)
    clampPlayerToMap()
    updateCameraFollow(target: player.position, deltaTime: deltaTime)
    clampCameraToMap()
}