Eim Mega-Jump-Spiel für iPhone machen – Teil 3

Eim Mega-Jump-Spiel für iPhone machen - Teil 3

Willkommen zum dritten Teil des Tutorials, im dem wir mit Sprite Kit und Swwenn t eim Spiel im Mega Jump-Stil erstellen. Im vorherigen Teil 1 und Teil 2 haben wir eim Sprite Kit-Spiel namens Uber Jump erstellt. Wir haben Grafiken, eim Helden-Sprite und einige Gameplay-Elemente hinzugefügt.

In Teil 3 werden wir diese Grundlage verwenden, um dwie gesamte Level des Spiels einschließlich des Punktesystems aufzubauen. Wir werden auch eine Beschleunigungsmesser-Unterstützung hinzufügen, damit sich unser ‘Ultra-Jumper’ von einer Seite zur anderen und von oben nach unten bewegen kann. Wenn wir alle fertig sind, haben Sie ein absolut vollständiges Spiel, dwie Sie dann in verschiedene Richtungen erweitern können. Wie in den ersten Teilen des Tutorials müssen Sie in diesem Material die Grundlagen des Sprite-Kits kennen. Willkommen auf dem nächsten Level!

Fortsetzung

Der Originalartikel in englischer Sprache ist hier verfügbar.

Laden Sie eine vollständige Kopie des Projekts aus dem ersten Teil herunter, wenn Sie es nicht selbst gemacht haben.

Unser Level wird viele Sterne und Plattzum men enthalten. Um eine manuelle Strukturierung der Daten zu vermeiden, laden Sie diese Level-Konfigurationsdatei herunter und ziehen Sie Level01.plist in Ihr Xcode-Projekt. Stellen Sie sicher, dwie s dwie Kontrollkästchen “Ziel:: : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : Elemente bei Bedarf kopieren” aktiviert und dwie UberJump-Ziel ausgewählt ist.

Öffnen Sie Level01.plist und überprüfen Sie den Inhalt. Es besteht im Wesentlichen aus drei Elementen:

– EndY bestimmt die Höhe, die der Held erreichen muss, um dwie Level zu beenden.

– Sterne bestimmt die Position aller Sterne im Level.

– Plattzum men definiert die Position aller Plattzum men in der Ebene.

Die Stars and Platzum ms-Elemente enthalten jeweils zwei verschachtelte Elemente:

– Muster enthält eine Reihe von Mustern für Sterne und Plattzum men.

– Positionen definiert die Position der Stern- und Plattformmuster im gesamten Level.

Ein Mega-Jump-Spiel für iPhone machen - Teil 3

Öffnen Sie zum besseren Verständnis der Dateistruktur das Element Sterne / Positionen / Element 0, das drei verschachtelte Elemente enthält, die Informationen mit folgendem Inhalt enthalten: Die Sterne müssen an der Stelle mit den Koordinaten 160 und 240 kreuzweise platziert werden.

Ein Mega-Jump-Spiel für iPhone machen - Teil 3

Schauen Sie sich nun Muster / Kreuz an und Sie werden ein Muster sehen, das fünf Elemente enthält, einschließlich der X- und Y-Koordinaten in Bezug auf die in Sterne / Positionen angegebene Position und die Art des Sterns. Der normale Typ wird mit Null und der spezielle Typ mit Eins bezeichnet.

Ein Mega-Jump-Spiel für iPhone machen - Teil 3

Dies ist eine recht bequeme Möglichkeit, Stern- und Plattformvorlagen wiederzuverwenden, ohne für jedes einzelne Objekt eine Position im Code festlegen zu müssen.

Ein Mega-Jump-Spiel für iPhone machen - Teil 3

Laden einer Ebene mit Daten

Öffnen Sie GameScene.swwenn t und fügen Sie der Klasse die folgende Eigenschaft hinzu, um die Möglichkeit zum Laden von Level-Parametern aus der Level01.plist-Datei hinzuzufügen:

// Höhe auf welcher Ebene endet  Lassen  endLevelY   = 0

 

EndLevelY speichert die Höhe oder Ordinate, die der Spieler erreichen muss, um das Level zu beenden.

Fügen Sie den folgenden Code direkt vor den Zeilen, mit denen die Plattform erstellt und hinzugefügt wird, in die Methode drin (size 🙂 ein:

// Lade das Level  Lassen  levelPlist   = NSBundle .mainBundle ().pathForResource ("Level01" ofType : "plist" ) Lassen  levelData     = NSDictionary         (contentOfFile : levelPlist!)! // Höhe, in der der Spieler das Level beendet  endLevelY = levelData[                         "EndY" ]] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] !.Int   eger Wert !

 

Dieser Code lädt die Daten aus der Eigenschaftsliste in ein Wörterbuch namens levelData, nimmt dann den Wert der EndY-Eigenschaft von dort und speichert ihn in der Variablen endLevelY.

Kommen wir nun zu den Sternen und Plattformen. Beginnen wir mit Plattformen: Ersetzen Sie in der Methode init (size 🙂 die folgenden Zeilen:

// Eine Plattform hinzufügen  Lassen  Plattform  = createPlatformAtPosition  (CGPoint             (x                : 160y : 320)ofType : .Normal ) foregroundNode.addChild     (Plattform )

 

mit diesem Code:

// Plattformen hinzufügen  Lassen  Plattformen  = levelData["Plattformen" ] as NSDictionary Lassen  Plattformmuster  = Plattformen ["Muster" ] as NSDictionary Lassen  Plattformpositionen  = Plattformen ["Positionen" ] as [NSDictionary] for platformPosition     in Plattformpositionen  {                    Lassen  Muster X     = platformPosition["x"    ].floatValue  Lassen  MusterY  = platformPosition["y"    ].floatValue  Lassen  Muster  = platformPosition["Muster" ] as NSString    // Muster nachschlagen  Lassen  Plattformmuster  = Plattformmuster [Muster ] as [NSDictionary] for platformPoint     in Plattformmuster  { Lassen  x = platformPoint["x"].floatValue  Lassen  y = platformPoint["y"].floatValue  Lassen  Art  = PlatformType (Rohwert : platformPoint["Art" ]!.Integer Wert ) Lassen  positionX   = CGFloat        (x! +        Muster X!) Lassen  positionY     = CGFloat(y! + MusterY !) Lassen  platformNode   = createPlatformAtPosition(CGPoint(x: positionXy   : positionY)ofType : Art !) foregroundNode.addChild(platformNode) }} } } } } } } } } } } } } } } } } } }  }

 

Hier ist viel los, aber diese Dinge sind ziemlich einfach. Wir haben das Plattformwörterbuch aus levelData geladen und dann die Plattformpositionen aus diesem Wörterbuch geloopt. Für jedes Element haben wir die entsprechende Vorlage erhalten und einen Plattformknoten des gewünschten Typs mit den angegebenen X- und Y-Positionen instanziiert. Schließlich haben wir alle Plattformknoten zum Vordergrundknoten hinzugefügt, der alle Spielobjekte enthalten sollte.

Bauen und ausführen. Sie sehen eine Reihe von drei horizontal ausgerichteten Plattformen vom Typ “Triple”, die in der Datei auf Level01.plist angegeben sind.

Ein Mega-Jump-Spiel für iPhone machen - Teil 3

Machen Sie jetzt dasselbe für die Sterne. Ersetzen Sie in GameScene.swwenn t die folgende Zeile in init (Größe :):

// Stern hinzufügen  Lassen  Star  = createStarAtPosition  (CGPoint(x: 160y : 220)ofType : .Besondere ) foregroundNode.addChild(Star )

 

Code:

// Füge die Sterne hinzu  Lassen  Sterne  = levelData["Sterne" ] as NSDictionary Lassen  starPattern  s   = Sterne ["Muster" ] as NSDictionary Lassen  starPosition    s   = Sterne ["Positionen" ] as [NSDictionary] for starPosition in starPositions { Lassen  patternX = starPosition["x"].floatValue  Lassen  MusterY  = starPosition["y"].floatValue  Lassen  pattern = starPosition["Muster" ] as NSString // Muster nachschlagen  Lassen  starPattern = starPatterns[pattern] as [NSDictionary] for starPoint     in starPattern { Lassen  x = starPoint["x"].floatValue  Lassen  y = starPoint["y"].floatValue  Lassen  Art  = StarType (Rohwert : starPoint["Art" ]!.Integer Wert ) Lassen  positionX = CGFloat(x! + patternX!) Lassen  positionY = CGFloat(y! + MusterY !) Lassen  starNode   = createStarAtPosition(CGPoint(x: positionXy : positionY)ofType : Art !) foregroundNode.addChild(starNode) } }

 

Alles hier ist genau das gleiche wie beim Erstellen der Plattformen, aber in diesem Fall verwenden wir das Stars-Wörterbuch anstelle des Platforms-Wörterbuchs.

Bauen und ausführen. Es sieht schon nach einem echten Spiel aus!

Ein Mega-Jump-Spiel für iPhone machen - Teil 3

Mittlere Grundschicht

Grafisch gibt es noch eine Möglichkeit, dem Spiel die Illusion von Lautstärke zu verleihen – dies ist die mittlere Grundschicht. Es wird den Knoten darstellen, der die Landschaftsgrafiken enthält.

Fügen Sie GameScene.swwenn t die folgende Methode hinzu:

func     createMidgroundNode  () ->  SKNode   { // Erstelle den Knoten  Lassen  theMidgroundNode   = SKNode() var         Anker : CGPoint! var xPosition   : CGFloat! // 1    // Fügen Sie dem Mittelgrund einige Zweige hinzu  for Index  in 0...neun  { var spriteName    : String // 2    Lassen  r = arc4random () %.  2 if r>  0 { spriteName = "BranchRight"  Anker  = CGPoint(x: 1.0 y : 0,5 ) xPosition = selbst .size.width    } sonst  { spriteName = "BranchLeft"  Anker  = CGPoint(x: 0.0      y : 0,5 ) xPosition = 0.0 } // 3   Lassen  branchNode   = SKSpriteNode (imageNamed : spriteName) branchNode.anchorPoint  = Anker branchNode.position  = CGPoint(x: xPositiony  : 500,0   CGFloat(Index )) theMidgroundNode.addChild (branchNode) } // Den fertigen Mittelknoten zurückgeben  Rückkehr  theMidgroundNode }

 

Schauen wir uns diesen Code genauer an:

1. Wir fügen dem midgroundNode zehn Zweige hinzu, die gleichmäßig über das Level verteilt sind.

2. Es gibt zwei verschiedene Bilder: Auf der einen Seite wachsen Zweige von der linken Seite des Bildschirms, auf der anderen Seite – von rechts. Wir nehmen eine zufällige.

3. Wir platzieren die Zweige in Abständen von 500 Punkten entlang der y-Achse am Mittelgrundknoten.

Fügen wir nun den Mittelknoten zur Bühne hinzu, indem wir den folgenden Code in init (Größe 🙂 direkt nach der Zeile einfügen, in der der Hintergrundknoten hinzugefügt wird:

// Midground  midgroundNode = createMidgroundNode() addChild(midgroundNode)

 

Bauen und ausführen.

Aussehen! Zweige verschiedener Art erschienen und einige hatten sogar rosa Schmetterlinge!

Ein Mega-Jump-Spiel für iPhone machen - Teil 3

Hinweis: Rosa Schmetterlinge erscheinen, wenn der zufällige Zweig der für die rechte Seite des Bildschirms gezeichnete ist. Das Bild für den linken Zweig enthält keine Schmetterlinge.

Klicken Sie hier, um das Spiel zu starten, und Sie werden ein Helden-Sprite auf dem Bildschirm sehen. Wenn jedoch der “Ultra-Jumper” steigt, bleibt die Spielwelt vorerst bestehen.

Ein Mega-Jump-Spiel für iPhone machen - Teil 3

Die Vordergrund-, Mittel- und Hintergrundebene müssen sich mit dem Heldenknoten bewegen, damit das Helden-Sprite auf dem Bildschirm zentriert bleibt. Darauf werden wir im nächsten Kapitel eingehen.

Parallaxe

interessante 6,1-Zoll iPhone 12 und iPhone 12 Pro wird zum ersten Mal in den Verkauf gehen. Abonnement-Paket startet Apple Einer bestätigt

Um unserem Spiel Parallaxe hinzuzufügen, bewegen wir den Vordergrund-, Mittel- und Hintergrundknoten mit unterschiedlichen Geschwindigkeiten, während der Held die Szene auf und ab bewegt. Das Sprite Kit ruft die aktualisieren () -Methode in unserer Szene in jedem Frame auf. Hier können Sie also die Logik implementieren, um eine reibungslose Animation zu gewährleisten.

Öffne GameScene.swift und füge die folgende Methode hinzu:

überschreiben  func update(aktuelle Uhrzeit : NSTimeInterval ) { // Spieler y Versatz berechnen  if Spielerposition .y     >  200,0  { backgroundNode.position  = CGPoint(x: 0.0y : -((Spielerposition .y - 200,0 )/10)) midgroundNode.position  = CGPoint(x: 0.0y : -((player.position.y - 200,0 )/4)) foregroundNode.position  = CGPoint(x: 0.0, y: -(player.position.y - 200,0 )) } }

 

Wir überprüfen, ob der Heldenknoten mehr als 200 Punkte über den Bildschirm bewegt hat, da wir sonst den Hintergrund nicht verschieben möchten. Wenn die Bedingung erfüllt ist, bewegen wir drei Knoten mit unterschiedlicher Geschwindigkeit nach unten, um einen Parallaxeeffekt zu erzeugen:

– Wir bewegen den Vordergrundknoten mit der gleichen Geschwindigkeit wie den Knoten des Helden, um zu verhindern, dass der Held den Bildschirm verlässt.

– Bewege den mittleren Knoten mit einer Geschwindigkeit, die 25% der Knotengeschwindigkeit des Helden entspricht, da diese Ebene weiter vom Betrachter entfernt sein sollte.

– Bewege den Hintergrundknoten mit einer Geschwindigkeit, die 10% der Knotengeschwindigkeit des Helden entspricht, da er noch weiter entfernt sein sollte.

Bauen und ausführen. Klicken Sie hier, um das Spiel zu starten. Sie werden sehen, dass sich jetzt alle Ebenen mit dem Helden bewegen und die unterschiedlichen Knotengeschwindigkeiten des Hintergrunds und des Mittelgrunds der Knoten einen sehr schönen Parallaxeeffekt erzeugen.

Ein Mega-Jump-Spiel für iPhone machen - Teil 3

Ausgezeichnete Arbeit! Aber es ist zu früh, um sich auf unseren Lorbeeren auszuruhen. Um zu den Sternen zu springen, müssen Sie zuerst den Boden graben.

Bewegung mit einem Beschleunigungsmesser

Es ist Zeit, den Beschleunigungsmesser zu benutzen. Die Bewegung entlang der vertikalen Achse ist für uns genau abgestimmt, aber was ist mit der Bewegung entlang der horizontalen Achse? Genau wie bei Mega Jump steuert der Benutzer seinen “Ultra-Jumper” mit dem Beschleunigungsmesser.

Hinweis: Um den Beschleunigungsmesser zu testen, müssen Sie das Spiel auf einem realen Gerät ausführen. iPhone Der Simulator funktioniert nicht mit dem Beschleunigungsmesser.

Sie benötigen die Core Motion-Bibliothek, um die Eingangssignale des Beschleunigungsmessers zu verarbeiten. Fügen Sie daher die folgende Zeile oben in GameScene.swift hinzu:

importieren  CoreMotion

 

Fügen Sie dann der GameScene-Klasse die folgenden Eigenschaften hinzu:

// Bewegungsmanager für Beschleunigungsmesser  Lassen  motionManager : CMMotionManager   = CMMotionManager() // Beschleunigungswert vom Beschleunigungsmesser  var x Beschleunigung : CGFloat = 0.0

 

Wir werden den MotionManager verwenden, um auf die Beschleunigungsmesserdaten des Geräts zuzugreifen, und wir werden auch den zuLassen zt berechneten Beschleunigungswert in der Variablen x Beschleunigung speichern, die wir später benötigen, wenn wir die Geschwindigkeit des Heldenknotens entlang der X-Achse einstellen.

Um eine CMMotionManager-Instanz zu erstellen, fügen Sie der init (size 🙂 -Methode direkt nach der Zeile, in der tapToStartNode zum HUD hinzugefügt wird, den folgenden Code hinzu:

// CoreMotion  // 1 motionManager.accelerometerUpdateInterval  = 0,2  // 2 motionManager.startAccelerometerUpdatesToQueue (NSOperationQueue .currentQueue ()mit Handler : { (BeschleunigungsmesserDaten : CMAccelerometerData !, Error : NSError !) in // 3 Lassen  Beschleunigung  = BeschleunigungsmesserDatenbeschleunigung  // 4  selbst .xBeschleunigung  = (CGFloat(Beschleunigung.x )  0,75 ) + (selbst .xBeschleunigung   0,25 ) })

 

Hier ist viel los, also lasst uns tiefer eintauchen:

1. Die Eigenschaft AccelerometerUpdateInterval bestimmt die Anzahl der Sekunden zwischen Aktualisierungen der Beschleunigungsmesserwerte. Ein Wert von 0,2 liefert die glatteste Bildwiederholfrequenz.

2. Wir führen den Beschleunigungsmesser aus und legen einen Codeblock fest, der bei jeder Aktualisierung der Beschleunigungsmesserwerte ausgeführt werden soll.

3. Innerhalb des Blocks erhalten wir Informationen zur Beschleunigung aus den Lassen zten an den Block übergebenen Beschleunigungsmesserdaten.

4. Hier berechnen wir die Beschleunigung des Heldenknotens entlang der X-Achse. Sie können diesen Wert direkt aus den Beschleunigungsmesserdaten abrufen. Die Bewegung wird jedoch viel ruhiger, wenn Sie den Wert verwenden, der drei Viertel der Beschleunigungsmesserbeschleunigung entlang der X-Achse und ein Viertel der aktuellen Beschleunigung entlang derselben Achse addiert.

Nachdem wir den Abszissenbeschleunigungswert haben, können wir damit die horizontale Geschwindigkeit des Heldenknotens einstellen.

Da Sie die Geschwindigkeit des Heldenknotens direkt steuern, ist es wichtig, dass Sprite Kit zuerst die Physik übernimmt.

Das Sprite Kit verfügt über eine Methode namens didSimulatePhysics , die für diesen Zweck in Ordnung ist. Sprite Kit ruft diese Methode auch einmal pro Frame auf, nachdem die Physik gerendert und ausgeführt wurde.

Fügen Sie GameScene.swift die folgende Methode hinzu:

überschreiben  func didSimulatePhysics() { // 1 // Geschwindigkeit basierend auf der Beschleunigung der x-Achse einstellen  player.physicsBody ? .velocity  = CGVector (dx : xAcceleration  400,0 dy : player.physicsBody!.velocity.dy ) // 2 // Überprüfen Sie die x-Grenzen  if player.position.x <  -20.0     { player.position = CGPoint(x: selbst .size.width + 20.0, y: player.position.y) } sonst  if (player.position.x>  selbst .size.width + 20.0) { player.position = CGPoint(x: -20.0, y: player.position.y) } }

 

Hier passieren mehrere Dinge:

1. Wir ändern die horizontale Komponente des Geschwindigkeitswertes des Heldenknotens mithilfe des xAcceleration-Werts. Dann multiplizieren wir es mit 400, weil die Skala des Beschleunigungsmessers nicht der Skala der realen Physik entspricht und wir durch Erhöhen des Wertes einen realistischeren Effekt erhalten. Wir lassen den Geschwindigkeitswert entlang der Y-Achse unverändert, da der Beschleunigungsmesser ihn in keiner Weise beeinflusst.

2. Wenn der Held im Megasprung den Bildschirm nach links oder rechts verlässt, kehrt er von der gegenüberliegenden Seite zurück. Wir verwenden hier das gleiche Verhalten, indem wir die Bildschirmränder überprüfen und den 20-Punkte-Rand vom Bildschirm lassen.

Erstellen und ausführen Sie auf Ihrem Gerät. Verwenden Sie den Beschleunigungsmesser, um das Helden-Sprite so hoch wie möglich zu heben!

Ein Mega-Jump-Spiel für iPhone machen - Teil 3

Punktesystem

Insgesamt wird unser Uber Jump-Spiel drei Arten von Informationen zu Helden enthalten:

1. Girokonto. Die Partitur beginnt bei Null. Je höher der Held wird, desto mehr Punkte werden zu Ihrer Punktzahl hinzugefügt. Sie erhalten außerdem Punkte für jeden Stern, den Sie sammeln.

2. Höchste Punktzahl. Am Ende jeder Spielrunde gibt es immer Endpunkte. Uber Jump schreibt die höchsten Werte in die Standarddatei des Benutzers, damit der Spieler weiß, welche Datensätze beschädigt werden müssen.

3. Sterne. Im Gegensatz zur aktuellen Punktzahl, die zu Beginn jedes Spiels zurückgesetzt wird, sammeln sich die Sterne des Helden von Spiel zu Spiel an. In einer zukünftigen Version von Uber Jump können Sie Sterne in eine spezielle Spielwährung umwandeln, für die Benutzer Upgrades und zusätzliche Optionen erwerben können. Wir werden dies nicht im Rahmen der aktuellen Lektion tun, aber wir werden eine solche Gelegenheit hinzufügen, falls Sie dies nach eigenem Ermessen tun möchten.

Wir werden eine laufende Punktzahl, die höchste Punktzahl und gesammelte Sterne in einer SingLassen on -Klasse namens GameState behalten. Diese Klasse schreibt wiederum die höchste Punktzahl und die Anzahl der Sterne in eine Datei auf dem Gerät, sodass die Werte zwischen den Spielstarts gespeichert werden.

Erstellen Sie eine neue iOS / Source / Swift-Datei mit dem Namen GameState. Fügen Sie GameState.swift die folgende Klassen- und Eigenschaftsbeschreibung hinzu:

class GameState { var Ergebnis : Int var HighErgebnis  : Int var Sterne : Int class var sharedInstance : GameState { struct  Singleton { statisch  let Beispiel  = GameState() } Rückkehr  Singleton.instance  } }

 

Die angegebenen drei Eigenschaften bieten Zugriff auf die aktuelle Punktzahl, die höchste Punktzahl und die Anzahl der Sterne. Die Klassenvariable sharedInstance ermöglicht den Zugriff auf eine einzelne Instanz der GameState-Klasse.

Wir benötigen auch eine Methode zum Initialisieren von GameState, die die aktuelle Punktzahl zurücksetzt sowie die höchste Punktzahl (falls vorhanden) und die Anzahl der Sterne aus der Benutzereinstellungsdatei lädt.

Fügen Sie die folgende Initialisierungsmethode für GameState.swift hinzu:

init() { // Drin  score = 0 Highscore  = 0 Sterne  = 0 // Spielstatus laden  let Standardeinstellungen  = NSUserDefaults   .standardUserDefaults   () Highscore  = Standardeinstellungen .integerForKey  ("Highscore" ) Sterne  = defaults.integerForKey("Sterne" ) }

 

Die Verwendung der NSUserDefaults-Klasse ist eine einfache Möglichkeit, eine kleine Datenmenge auf einem Gerät zu speichern. Dies gilt für Benutzereinstellungen. In diesem Beispiel wird jedoch die höchste Punktzahl und Anzahl der Sterne gespeichert. In einer realen Anwendung möchten Sie höchstwahrscheinlich etwas Zuverlässigeres als NSUserDefaults verwenden, damit niemand die dort gespeicherten Daten leicht ändern und mehr Sterne für sich selbst schreiben kann, als er verdient hat!

Hinweis: Weitere Informationen zum Speichern von Spieldaten finden Sie im Lernprogramm zum Speichern Ihrer Spieldaten.

Wir benötigen eine Methode in GameState, um die angegebenen Werte zu speichern. Fügen Sie GameState.swift die folgende Methode hinzu:

func sicherer Staat () { // HighScore aktualisieren, wenn die aktuelle Punktzahl höher ist  Highscore  = max (Punktzahl, HighScore ) // In den Benutzerstandards speichern  let defaults = NSUserDefaults.standardUserDefaults() defaults.setInteger  (HighScore, forKey : "Highscore" ) defaults.setInteger(Sterne, forKey : "Sterne" ) NSUserDefaults.standardUserDefaults().synchronisieren () }

 

Hier ist die GameState-Klasse, die mit dem Speicher auf dem Gerät synchronisiert wird.

Wir haben ein fast funktionierendes Projekt, im nächsten letzten Teil werden wir uns an alles erinnern und eine echte Spieleanwendung bekommen!

Rate article
Handys - Nachrichten, Bewertungen und Life Hacks.
Add a comment