How can I update an object's position only when the iPhone is tilted left or right in Swift?

In your current code you update the tilt angle based solely on gravity.x. That works fine when the device is upright in portrait mode, but when the device is rotated (so that moving it up/down also affects the x component) you see unwanted changes. One common solution is to update the angle only when the device is “upright” (or at least sufficiently vertical) by checking the vertical component of gravity (gravity.y) and only using gravity.x when the device is in the expected orientation.

For example, you can add a threshold that “ignores” updates when the device isn’t held in portrait. In portrait mode the gravity vector will have a large y component (close to 1 in magnitude). In contrast, if the device is horizontal (or rotated) the y value will drop below that threshold. You can then ignore the roll updates (or set them to zero) when the phone is not in “upright” orientation.

One way to modify your startMotionUpdates method is as follows:

---

import SwiftUI
import CoreMotion

struct LevelView: View {
@StateObject private var motionManager = MotionManager()

var body: some View {
    GeometryReader { geometry in
        ZStack {
            VStack(spacing: 0) {
                Rectangle()
                    .fill(Color.white)
                    .frame(height: geometry.size.height / 2)
                
                Rectangle()
                    .fill(Color.orange)
                    .frame(height: geometry.size.height / 2)
            }
            .rotationEffect(.degrees(motionManager.tiltAngle), anchor: .center)
        }
    }
}

}

class MotionManager: ObservableObject {
private var motion = CMMotionManager()
@Published var tiltAngle: Double = 0.0

init() {
    startMotionUpdates()
}

private func startMotionUpdates() {
    if motion.isDeviceMotionAvailable {
        motion.deviceMotionUpdateInterval = 1.0 / 60.0 // 60 FPS
        motion.startDeviceMotionUpdates(to: .main) { (data, error) in
            if let data = data {
                // Use the gravity vector to determine device orientation.
                // In portrait mode, gravity.y should be near 1.
                let gravity = data.gravity
                // Set a threshold (for example, 0.8) - if the y component is below that,
                // we assume the device is not held vertically and ignore the roll update.
                let verticalThreshold = 0.8
                DispatchQueue.main.async {
                    if abs(gravity.y) > verticalThreshold {
                        // Only update tiltAngle when the device is sufficiently vertical.
                        // Compute the "roll" angle from gravity.x.
                        let rollAngle = gravity.x * 180 / .pi
                        self.tiltAngle = rollAngle
                    } else {
                        // When the device is rotated away from vertical, you might want
                        // to either lock the tilt value or set it to zero.
                        self.tiltAngle = 0.0
                    }
                }
            }
        }
    }
}

}

In this example, the code checks the absolute value of gravity.y. When the phone is held vertically (for example, in portrait), gravity.y is near 1 so the condition is met and the tiltAngle is updated from gravity.x. If the phone is turned horizontal (or rotated so that gravity.y falls below the threshold), the tiltAngle is reset (or you could choose not to update it).

Feel free to adjust the threshold value (here 0.8) to better suit your particular needs. Another approach is to use the device’s attitude (and possibly adjust using the device orientation) rather than raw gravity, but the threshold method is a quick way to filter out unwanted updates based on how the phone is held.

This change should ensure that only left/right tilting (when the device is upright) causes the object to change its rotation.