如何为Swift开发的SpriteKit游戏通过Game Center实现实时多人功能

Hey there! I’ve been in your exact spot before—trying to add real-time multiplayer to a solid SpriteKit game and coming up short on Swift-specific step-by-step guides. Let’s break this down into actionable steps that’ll get you up and running with Game Center (Apple’s built-in multiplayer framework) since that’s the most seamless fit for SpriteKit.

First, you need to enable Game Center in your Xcode project and authenticate the local player. This is non-negotiable—it’s the foundation of everything else.

1. Enable Game Center Capability:

   • Go to your project target → Signing & Capabilities → Click the "+ Capability" button → Add "Game Center".
   • Make sure your app ID (in Apple Developer Portal) has Game Center enabled too.

2. Authenticate the Local Player:
   Create a singleton GameManager class to handle all Game Center logic (keeps your SpriteKit scene clean). Here’s the Swift code to authenticate and start matchmaking:

   import GameKit
   import UIKit
   
   class GameManager: NSObject, GKGameCenterControllerDelegate, GKMatchmakerViewControllerDelegate {
       static let shared = GameManager()
       var currentMatch: GKMatch?
       private let localPlayer = GKLocalPlayer.local
   
       private override init() { super.init() }
   
       func authenticatePlayer() {
           localPlayer.authenticateHandler = { [weak self] viewController, error in
               guard let self = self else { return }
               if let authVC = viewController {
                   // Present the login VC if the player isn't signed in
                   if let rootVC = UIApplication.shared.connectedScenes
                       .compactMap({ $0 as? UIWindowScene })
                       .first?.windows.first?.rootViewController {
                       rootVC.present(authVC, animated: true)
                   }
               } else if self.localPlayer.isAuthenticated {
                   print("Player authenticated! Ready to find matches.")
                   self.startMatchmaking()
               } else {
                   print("Authentication failed: \(error?.localizedDescription ?? "Unknown error")")
               }
           }
       }
   
       func startMatchmaking() {
           let matchRequest = GKMatchRequest()
           matchRequest.minPlayers = 2 // Adjust to your game's minimum players
           matchRequest.maxPlayers = 4 // Adjust to your game's maximum players
           matchRequest.inviteMessage = "Let's play my SpriteKit game!"
   
           let matchmakerVC = GKMatchmakerViewController(matchRequest: matchRequest)
           matchmakerVC.matchmakerDelegate = self
   
           if let rootVC = UIApplication.shared.connectedScenes
               .compactMap({ $0 as? UIWindowScene })
               .first?.windows.first?.rootViewController {
               rootVC.present(matchmakerVC, animated: true)
           }
       }
   
       // MARK: - GKMatchmakerViewControllerDelegate
       func matchmakerViewControllerWasCancelled(_ viewController: GKMatchmakerViewController) {
           viewController.dismiss(animated: true)
       }
   
       func matchmakerViewController(_ viewController: GKMatchmakerViewController, didFailWithError error: Error) {
           print("Matchmaking failed: \(error.localizedDescription)")
           viewController.dismiss(animated: true)
       }
   
       func matchmakerViewController(_ viewController: GKMatchmakerViewController, didFind match: GKMatch) {
           viewController.dismiss(animated: true)
           self.currentMatch = match
           match.delegate = self
           // Notify your SpriteKit scene that the match is ready to start
           NotificationCenter.default.post(name: NSNotification.Name("MatchFound"), object: nil)
       }
   }
   

   Call GameManager.shared.authenticatePlayer() when your game starts (e.g., in your GameViewController’s viewDidLoad).

Once you have a match, you need to send/receive data between players. GameKit uses GKMatch to handle this—here’s how to integrate it with your SpriteKit scene:

1. Send Player Data:
   In your SpriteKit scene, when the local player moves or performs an action, send that data to other players. For example, sending a player’s position:

   func sendLocalPlayerPosition() {
       guard let match = GameManager.shared.currentMatch else { return }
       let positionData = ["x": playerNode.position.x, "y": playerNode.position.y]
       if let jsonData = try? JSONSerialization.data(withJSONObject: positionData) {
           do {
               try match.sendData(toAllPlayers: jsonData, with: .reliable)
           } catch {
               print("Failed to send position data: \(error.localizedDescription)")
           }
       }
   }
   

   Call this method whenever your player’s position updates (e.g., in update(_:) or after a touch input).

2. Receive & Process Remote Player Data:
   Extend your GameManager to handle incoming data and update your SpriteKit scene:

   extension GameManager: GKMatchDelegate {
       func match(_ match: GKMatch, didReceive data: Data, fromRemotePlayer player: GKPlayer) {
           guard let positionDict = try? JSONSerialization.jsonObject(with: data) as? [String: CGFloat] else { return }
           let remotePosition = CGPoint(x: positionDict["x"] ?? 0, y: positionDict["y"] ?? 0)
   
           // Always update UI on the main thread—GameKit callbacks run in background
           DispatchQueue.main.async {
               NotificationCenter.default.post(name: NSNotification.Name("RemotePlayerPositionUpdated"), object: remotePosition)
           }
       }
   
       func match(_ match: GKMatch, player playerID: String, didChange state: GKPlayerConnectionState) {
           switch state {
           case .disconnected:
               print("Player disconnected: \(playerID)")
               // Notify your scene to handle a player leaving (e.g., show a game over screen)
               DispatchQueue.main.async {
                   NotificationCenter.default.post(name: NSNotification.Name("PlayerDisconnected"), object: nil)
               }
           case .connected:
               print("Player connected: \(playerID)")
           default:
               break
           }
       }
   }
   

   In your SpriteKit scene, observe these notifications to update the remote player’s node:

   override func didMove(to view: SKView) {
       NotificationCenter.default.addObserver(self, selector: #selector(handleRemotePositionUpdate(_:)), name: NSNotification.Name("RemotePlayerPositionUpdated"), object: nil)
       NotificationCenter.default.addObserver(self, selector: #selector(handlePlayerDisconnection), name: NSNotification.Name("PlayerDisconnected"), object: nil)
   }
   
   @objc func handleRemotePositionUpdate(_ notification: Notification) {
       guard let position = notification.object as? CGPoint else { return }
       remotePlayerNode.position = position
   }
   
   @objc func handlePlayerDisconnection() {
       // Show a message or end the game
       let gameOverLabel = SKLabelNode(text: "Opponent left!")
       gameOverLabel.position = CGPoint(x: size.width/2, y: size.height/2)
       addChild(gameOverLabel)
   }
   

• Use Reliable vs. Unreliable Data: Use .reliable for critical data (like player positions, scores) and .unreliable for non-essential updates (like particle effects) to save bandwidth.
• Throttle Data Sends: Don’t send position updates every frame—limit it to 30-60 times per second to avoid lag.
• Test with Real Devices: Simulators can work, but testing on two physical devices with separate Apple IDs is the only way to catch real-world issues.
• Handle Edge Cases: What if a player loses internet? What if the match times out? Add error handling for these scenarios to keep your game stable.

内容的提问来源于stack exchange，提问作者Garrett