Ein Mega-Jump-Spiel für iPhone machen – Teil 2

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

Wir setzen das Tutorial zum Erstellen eines Spiels für iPhone auf Sprite Kit und Swwenn t fort. Im ersten Teil haben wir es geschafft, eine Spielszene zu erstellen, in der sich unser Held befindet, und ihn sogar dazu zu bringen, den Gesetzen der Schwerkraft zu gehorchen. In dieser Lektion werden wir dem Berg beibringen, mit der Außenwelt zu interagieren, “Sterne” zu fangen und auf Plattformen zu springen …

“Zum Star ten klicken”

Der Originalartikel in englischer Sprache kann hier gelesen werden.

Jetzt, da die Schwerkraft im Spiel funktioniert, müssen Sie den physischen Körper des Helden bewegungslos machen, bis der Benutzer beschließt, das Spiel zu Star ten. Suchen Sie in der Datei GameScene .swwenn t die Zeile in der Methode createSpieler , mit der die dynamische Eigenschaft auf den physischen Körper des Spieler Node-Objekts festgelegt wird. Ändern Sie den Wert wie hier gezeigt in falsch :: : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : :

 Spieler Node.physicsBody?  .dynamisch   = falsch 

 

Wir werden einen Code schreiben, mit dem der Benutzer das Spiel Star ten kann, indem er auf den Bildschirm klickt. Und er muss mit einer Art Inschrwenn t davor gewarnt werden. Zum Beispiel: “Zum Starten tippen”. Lassen Sie uns diese Anweisung auf den Bildschirm bringen.

Da sich die Anweisungen in der HUD-Ebene befinden, erstellen Sie sie zuerst. Fügen Sie in der Methode init (size 🙂 direkt nach dem Hinzufügen des Vordergrundknotens zur Bühne den folgenden Code ein:

// HUD  hudNode   = SKNode     () addChild (hudNode)

 

Zu den grafischen Elementen gehört ein Bild, auf das Sie klicken müssen, um das Spiel zu Star ten. Fügen Sie den Eigenschaften oben in GameScene.swwenn t die folgende Variable hinzu:

// Tippen Sie auf, um den Knoten zu starten  Lassen  tapToStartNode   = SKSpriteNode         (imageNamed      : "Tippe, um zu starten" )

 

Um den neu erstellten Knoten anzuzeigen, fügen Sie der Methode init (size 🙂 direkt nach der Zeile, in der der Heldenknoten hinzugefügt wird, den folgenden Code hinzu:

// Tippe, um zu starten  tapToStartNode.Position   = CGPoint         (x      : selbst .size.width  / 2y : 180,0 ) hudNode.addChild (tapToStartNode)

 

Erstellen und ausführen, um “Tap to start” direkt über dem Helden-Sprite zu sehen:

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

Fügen Sie der GameScene.swwenn t-Klasse die folgende Methode hinzu, um mit Berührungen umzugehen und mit dem Spielen zu beginnen:

überschreiben  func          berührtBegan (berührt : NSSet , mit Ereignisereignis : UIEvent ) {                           // 1       // Wenn wir bereits spielen, ignoriere Berührungen  wenn  Spieler .physicsBody   !.dynamic { Rückkehr  }} } } } } } } } } } } } } } } } } } } } } } } }  // 2       // Entfernen Sie den Knoten Tap to Start  tapToStartNode.removeFromParent     () // 3       // Starten Sie den Player, indem Sie ihn in die Physiksimulation einfügen  Spieler .physicsBody? .dynamic  = wahr  // 4     Spieler .physicsBody? .applyImpulse (CGVector   (dx   : 0.0 dy : 20.0 )) }

 

Schauen wir uns diese Methode genauer an:

1. Wir müssen sicherstellen, dass der Heldenknoten dynamisch ist. Wenn ja, ignorieren Sie einfach das Berührungsereignis.

2. Entfernen Sie den Knoten mit der Bezeichnung “Zum Starten tippen”.

3. Wir machen den physischen Körper des Knotens des Helden dynamisch, damit die Physik-Engine ihn beeinflussen kann.

4. Wir informieren den Knoten des Helden über den anfänglichen Aufwärtsimpuls, damit er sich in Bewegung setzt.

Bauen und ausführen. Wenn Sie auf den Bildschirm klicken, verschwindet die Inschrwenn t “Tab to start” und das Sprite des Helden wird hochgeschleudert, aber nicht lange – die Schwerkraft fordert ihren Tribut.

Spielobjekte: Greifen Sie nach den Sternen!

Um Ihrem Charakter etwas anderes zu geben als nur aufzuspringen, ist es Zeit, Sterne hinzuzufügen. Sterne spielen in Uber Jump eine wichtige Rolle: Sie müssen vom Spieler gesammelt werden, um zum nächsten Level zu gelangen.

Um loszulegen, müssen Sie nur einen Stern im Spiel erstellen und es voll funktionsfähig machen. Im nächsten Teil der Lektion werden wir das gesamte Level abschließen.

Gemäß dem Szenario des Spiels Uber Jump wird dieses Objekt wie Mega Jump aus der Szene entfernt, wenn sich das Sprite des Helden um eine bestimmte Entfernung über den Stern, die Plattform oder ein anderes Objekt erhebt. Da sowohl Knoten als auch Sterne und Plattformen diese Bedingung erfüllen, ist es sinnvoll, SKNode für alle Spielobjekte in Unterklassen zu unterteilen.

Erstellen Sie eine neue Cocoa Touch-Klasse mit dem Namen GameObjectNode und der Unterklasse SKNode. Stellen Sie sicher, dass Swift als Sprache installiert ist.

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

Die GameObjectNode-Klasse enthält die folgenden Funktionen:

1. Entfernen Sie das Objekt aus der Szene, von dem sich der Knoten des Helden in einer Entfernung entfernt hat, die größer als die angegebene ist.

2. Erkennen von Kollisionen zwischen dem Heldenknoten und dem Objekt. Diese Methode gibt einen booleschen Wert zurück, der benachrichtigt, wenn sich der Held mit einem Objekt im Spiel überschnitten hat, wodurch die HUD-Ebene aktualisiert wird. Zum Beispiel, wenn der Spieler Punkte erzielt hat.

Ersetzen Sie den Code in GameObjectNode.swift durch Folgendes:

importieren  SpriteKit  Klasse  GameObjectNode: SKNode { func collisionWithPlayer   (player: SKNode) ->    Bool    { Rückkehr  falsch  } func checkNodeRemoval (SpielerY : CGFloat ) { if SpielerY>  selbst .Position .y    +  300,0  { selbst .removeFromParent() } } }

 

Wir rufen die collisionWithPlayer-Methode immer dann auf, wenn der Heldenknoten mit einem Objekt kollidiert, und wir rufen jeden Frame checkNodeRemoval auf, damit wir den unnötigen Knoten sofort aus der Szene entfernen können.

In der GameObjectNode-Klasse ist die collisionWithPlayer-Methode nur ein Stub. Wir werden die vollständige Methode in jeder der Unterklassen, die für Ihre Spielobjekte erstellt werden, separat definieren.

Die checkNodeRemoval-Methode prüft, ob der Knoten des Helden mehr als 300 Punkte von diesem Knoten entfernt hat. In diesem Fall entfernt die Methode den Knoten von seinem übergeordneten Knoten und damit von der Szene.

Sternklasse

Jetzt, da wir eine Basisklasse für die interaktiven Knoten des Spiels haben, können wir eine Klasse für die Sterne erstellen. Um die Dinge einfach zu halten, fügen wir der GameObjectNode.swift-Datei alle GameObjectNode-Unterklassen gleichzeitig hinzu. Fügen Sie nach der GameObjectNode-Klasse den folgenden Code hinzu.

Klasse  StarNode  : GameObjectNode { überschreiben  func collisionWithPlayer(player: SKNode) -> Bool { // Steigere den Player  player.physicsBody? .velocity  = CGVector(dx: player.physicsBody!.velocity.dx, dy  : 400,0 ) // Entferne diesen Stern  selbst .removeFromParent() // Das HUD muss aktualisiert werden, um die neuen Sterne und die Punktzahl anzuzeigen  Rückkehr  wahr  } }

 

Eine Kollision mit einem Stern wirft den Knoten des Helden auf die Ordinate. Sie könnten fragen: “Warum nutzen wir nicht die Kraft oder den Impuls der Physik-Engine, um dies zu tun?”

Wenn wir Kraft oder Impuls anwenden würden, wäre der gewünschte Effekt nicht immer da. Wenn sich beispielsweise der Knoten eines Helden auf dem Bildschirm nach unten bewegt und gegen einen Stern stößt, ist die Einflusskraft auf den Helden viel geringer als beim Aufwärtsbewegen.

Das folgende Diagramm zeigt dies sehr deutlich:

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

Die Lösung für dieses Problem besteht darin, die Geschwindigkeit des Spielerknotens direkt zu ändern. Wie Sie wissen, besteht der Geschwindigkeitsvektor aus horizontalen und vertikalen Komponenten.

Die Geschwindigkeit der X-Achse sollte sich nicht ändern, da sie nur vom Beschleunigungsmesser beeinflusst wird, den wir später implementieren werden. Bei der obigen Methode setzen wir bei einer Kollision die vertikale Projektionsgeschwindigkeit auf einen festen Wert von 400. Damit die Kollision die gleichen Konsequenzen hat, unabhängig davon, was der Spieler vor der Kollision mit dem Stern getan hat.

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

func createStarAtPosition    (Position : CGPoint) -> StarNode   { // 1 Lassen  Knoten  = StarNode() Lassen  die Position  = CGPoint(x: position.x    scaleFactory   : position.y) Knoten .position   = die Position  Knoten .name   = "NODE_STAR"  // 2 var       Sprite : SKSpriteNode Sprite  = SKSpriteNode(imageNamed: "Star"  ) Knoten .addChild   (Sprite ) // 3 node.physicsBody   = SKPhysicsBody  (Kreis von Radius : Sprite .size .width  / 2) // 4 node.physicsBody? .dynamic  = falsch  Rückkehr  node }

 

Der obige Code sollte Ihnen inzwischen bekannt sein:

1. Wir erstellen eine Instanz der StarNode-Klasse und legen ihre Position fest.

2. Fügen Sie als Nächstes die Sterngrafiken mit SKSpriteNode hinzu.

3. Fügen Sie dem Knoten einen physischen Körper in Form eines Kreises hinzu, den wir benötigen, um Kollisionen mit anderen Objekten im Spiel zu erkennen.

4. Schließlich machen wir den physischen Körper statisch, weil wir nicht wollen, dass die Schwerkraft oder andere physikalische Simulationen die Sterne beeinflussen.

Fügen Sie nun den folgenden Code zur Methode init (size 🙂 hinzu, kurz bevor wir den Heldenknoten erstellt haben. Wir möchten, dass sich die Sterne hinter dem Spieler befinden, aber auch auf dem Vordergrundknoten. Daher müssen wir sie vor dem Knoten des Spielers hinzufügen.

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

 

Erstellen Sie das Spiel und führen Sie es aus. Klicken Sie auf den Startknopf und beobachten Sie, wie das Helden-Sprite mit dem Stern kollidiert.

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

Unser Ulta, der Springer, traf seinen Kopf auf dem Stern. Es lief nicht nach Plan! Warum denkst du, ist das passiert? Versuchen zu erraten.

Und hier ist die Lösung:

Die Physik-Engine behandelt Kollisionen zwischen dem Helden und den Sternenknoten. Der physische Körper des Heldenknotens kreuzt den physischen Körper des Sternenknotens, der statisch und daher bewegungslos ist. Der Sternenknoten stoppt die Bewegung des Spielerknotens.

Kollisionserkennung und Bitmasken

Um Kollisionen zwischen dem Helden und den Sternenknoten zu erkennen, müssen wir das Kollisionsereignis empfangen und die collisionWithPlayer-Methode der GameObjectNode-Klasse aufrufen.

Jetzt ist es an der Zeit, sich mit dem Thema der sich überschneidenden Bitmasken im Sprite-Kit zu befassen.

Es gibt drei bitmaskenbezogene Eigenschaften für die Übermittlung von Kollisionsinformationen an physische Körper, mit denen Sie bestimmen können, wie der physische Körper mit anderen physischen Körpern im Spiel interagiert.

1.categoryBitMask definiert die Kollisionskategorie, zu der der physische Körper gehört.

2. collisionBitMask legt die Kollisionskategorie der Körper fest, mit denen sich der angegebene Körper schneidet. Hier bedeutet das Wort “schneiden”, dass die Objekte genau miteinander kollidieren. Wenn Sie beispielsweise als Third-Person-Shooter spielen, möchten Sie, dass das Sprite des Helden mit feindlichen Sprites kollidiert, aber die Sprites anderer Spieler durchläuft.

3. Kontakt TestBitMask weist die Sprite Kit-Engine an, Sie zu benachrichtigen, wenn ein bestimmter physischer Körper mit physischen Körpern in Kontakt kommt, die zu einer der von Ihnen angegebenen Kategorien gehören. In unserem Spiel möchten wir beispielsweise, dass das Sprite-Kit uns mitteilt, wann das Sprite eines Spielers einen Stern oder eine Plattform berührt. Durch die Verwendung der richtigen Einstellungskombinationen für contactTestBitMask und collisionBitMask können Sie das Sprite Kit so programmieren, dass sich Objekte gegenseitig passieren, und Sie werden benachrichtigt, wenn dies geschieht. Auf diese Weise können wir Ereignisse auslösen.

Als erstes müssen Sie Ihre Kategorien festlegen. Öffne GameObjectNode.swift und füge die folgende Struktur über den Klassendefinitionen hinzu:

struct  CollisionCategoryBitmask  { statisch  Lassen  Player: UInt  32    = 0x00  statisch  Lassen  Star: UInt32 = 0x01  statisch  Lassen  Plattform : UInt32 = 0x02  }

 

Kehren Sie zu GameScene.swift zurück. Um das Verhalten des Helden bei Kollisionen festzulegen, fügen Sie den folgenden Code am Ende der createPlayer-Methode unmittelbar vor der Rückkehr -Anweisung hinzu:

// 1 playerNode.physicsBody? .usesPreciseCollisionDetection  = wahr  // 2 playerNode.physicsBody? .categoryBitMask  = CollisionCategoryBitmask.Player  // 3 playerNode.physicsBody? .collisionBitMask  = 0 // 4 playerNode.physicsBody? .contactTestBitMask  = CollisionCategoryBitmask.Star |  CollisionCategoryBitmask.Platform

 

Schauen wir uns diesen Codeblock genauer an:

interessante 6,1-Zoll iPhone 12 und iPhone 12 Pro werden zuerst in den Handel kommen Apple werden von Tag zu Tag den Start von iPhone 12 ankündigen

1. Da dies ein sich schnell bewegendes Spiel ist, muss Sprite Kit eine genaue Kollisionserkennung für den physischen Körper des Heldenknotens verwenden. Immerhin baut die gesamte Handlung von Uber Jump auf diesen Kollisionen auf. Deshalb müssen sie so genau wie möglich erfasst werden! (Es werden mehrere CPU-Zyklen beteiligt sein)

2. Wir weisen der physischen Körperbitmaske eine Kategorie zu. Es gehört zur Kategorie CollisionCategoryPlayer.

3. Indem Sie collisionBitMask auf Null setzen, teilen wir dem Sprite Kit mit, dass es keine Kollision des Spielerknotens simulieren soll. Dies liegt daran, dass wir diese Kollisionen selbst behandeln werden!

4. Wir teilen Sprite Kit mit, dass wir benachrichtigt werden möchten, wenn ein Heldenknoten Sterne oder Plattformen berührt.

Nun richten wir den Sternenknoten ein. Fügen Sie vor der Rückkehr -Anweisung den folgenden Code am Ende der createStarAtPosition-Methode hinzu:

 node.physicsBody? .categoryBitMask  = CollisionCategoryBitmask.Star node.physicsBody? .CollisionBitMask  = 0

 

Alles hier ähnelt dem Einrichten eines Heldenknotens. Wir weisen die Sternenkategorie zu und setzen die Eigenschaft collisionBitMask auf Null, damit sie mit nichts kollidiert. Wir weisen hier jedoch keine contactTestBitMask zu, was bedeutet, dass Sprite Kit uns nicht benachrichtigt, wenn ein Objekt den Stern berührt. Schließlich haben wir Sprite Kit bereits angewiesen, Benachrichtigungen zu senden, wenn der Held einen Stern berührt, und außer dem Stern wird er nichts berühren, sodass keine Benachrichtigungen vom Stern gesendet werden müssen.

Sprite Kit sendet Kontaktbenachrichtigungen für die von uns ausgewählten Knoten, indem die didBeginContact -Methode des SKPhysicsContact Delegate-Delegaten aufgerufen wird. Legen Sie die Szene selbst als Delegierten der physischen Welt fest, indem Sie das SKPhysicsContactDelegate-Protokoll zur GameScene-Klassendefinition hinzufügen. Es sollte ungefähr so ​​aussehen:

class GameScene: SKScene , SKPhysicsContactDelegate  { // Überlagerte Knoten  ...

 

Machen Sie die Szene nun zu einem Delegierten, der Kontaktbenachrichtigungen erhält, indem Sie init (Größe 🙂 direkt nach der Zeile, die die Schwerkraft festlegt, die folgende Zeile hinzufügen:

// Kontaktdelegierten setzen  physicsWorld.contactDelegate  = selbst 

 

Fügen Sie abschließend GameScene.swift die folgende Methode hinzu, um Kollisionsereignisse zu behandeln:

func didBeginContact(contact: SKPhysicsContact) { // 1 var updateHUD    = falsch  // 2 Lassen  whichNode   = (contact.bodyA.node   ! =  player) ? contact.bodyA.node : contact.bodyB.node  Lassen  andere  = whichNode as GameObjectNode // 3 updateHUD = other.collisionWithPlayer (player) // Aktualisiere das HUD falls nötig  if updateHUD { // 4 TODO: Aktualisiere das HUD in Teil 2  } }

 

Schauen wir uns diesen Code genauer an:

1. Wir initialisieren das UpdateHUD-Flag, das wir am Ende der Methode verwenden, um das HUD während dieser Kollisionen zu aktualisieren und die Punktzahl zu berechnen.

2. SKPhysicsContact garantiert nicht, welcher physische Körper als Körper A und welcher als Körper B fungiert. Wir wissen jedoch, dass alle Kollisionen in diesem Spiel zwischen dem Heldenknoten und dem GameObjectNode stattfinden. Daher bestimmt diese Zeile, welcher kein Heldenknoten ist.

3. Nachdem wir festgestellt haben, welches Objekt kein Heldenknoten ist, rufen wir die collisionWithPlayer: -Methode in der GameObjectNode-Klasse auf.

4. Hier aktualisieren wir bei Bedarf das HUD. Wir werden die HUD-Implementierung im zweiten Teil der Lektion durchführen, daher gibt es hier nichts außer einem Kommentar.

Erstellen Sie das Spiel und führen Sie es aus. Klicken Sie hier, um zu beginnen. Bei einer Kollision wirft der Stern das Sprite des Helden auf eine bestimmte Höhe und wird dann von der Szene entfernt. Gut gemacht!

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

Nun, es wurde viel harte Arbeit geleistet! Machen wir eine wohlverdiente Pause. Im nächsten Abschnitt werden wir neue Arten von Übersternen sowie einen Soundeffekt hinzufügen.

Hinweis: Wenn Sie mehr über die Pin- und Kollisionserkennung im Sprite Kit erfahren möchten, lesen Sie das Tutorial “iOS Games by Tutorials”, das drei große Kapitel zur Motorphysik enthält.

Verschiedene Arten von Sternen

Uber Jump enthält zwei Arten von Sternen: diejenigen, die einen Punkt hinzufügen, und spezielle Sterne, die fünf Punkte gleichzeitig hinzufügen. Jeder Stern hat seine eigene Grafik. Die Sammlung in der StarNode-Klasse hilft uns, den Sterntyp zu identifizieren.

Fügen Sie die folgende Sammlung oben in GameObjectNode.swift hinzu:

Aufzählung  StarType   : Int { Fall  Normal   = 0 Fall  Besondere  }

 

Fügen Sie zum Speichern des Sterntyps die folgende Eigenschaft oben in der StarNode-Klasse hinzu:

var starType : StarType!

 

Wenn Sie nun einen Stern erstellen, müssen Sie seinen Typ angeben. Fügen Sie daher in GameScene.swift den Parameter starType zur Signatur der Methode createStarAtPosition: hinzu, damit er folgendermaßen aussieht:

func createStarAtPosition(position: CGPointofType -Typ : StarType) -> StarNode {

 

Ersetzen Sie in createStarAtPosition (Position: ofType 🙂 die drei Codezeilen (die den SKSpriteNode erstellen und hinzufügen) durch Folgendes:

node.starType  = Art  var Sprite : SKSpriteNode if Art  ==    .Besondere  { Sprite  = SKSpriteNode(imageNamed: "StarSpecial" ) } sonst  { Sprite  = SKSpriteNode(imageNamed: "Star") } node.addChild(Sprite )

 

Zuerst setzen wir den Sterntyp. Anschließend überprüfen wir den Typ beim Erstellen des Sprites, um das entsprechende Bild hinzuzufügen.

Es bleibt nur die Art des Sterns beim Erstellen anzugeben. Suchen Sie in der init (size 🙂 -Methode der GameScene.swift-Klasse die Zeile, in der wir createStarAtPosition aufrufen, und ändern Sie sie wie folgt:

Lassen  star = createStarAtPosition(CGPoint(x: 160y : 220)ofType : .Besondere )

 

Weisen Sie unserem Stern StarType.Special zu.

Build Run. Unser Stern wurde rosa! Später werden wir ein Bewertungssystem hinzufügen und die Unterschiede in den SternArt n werden deutlicher.

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

Klingeln! Hinzufügen eines Soundeffekts

Es wäre schön, wenn die Kollision des Helden mit dem Stern von einem Tonsignal begleitet würde. Laden Sie hier den Star-Soundeffekt herunter und ziehen Sie die Datei in unser Xcode-Projekt. Stellen Sie sicher, dass die Option “Ziel: Elemente bei Bedarf kopieren” ausgewählt und das UberJump-Ziel ausgewählt ist.

Sprite Kit verwendet SKAction zum Abspielen von Sounds. Öffne GameObjectNode.swift und füge die folgende Klasseneigenschaft über StarNode hinzu:

Lassen  starSound  = SKAction.playSoundFileNamed ("StarPing.wav" , waitForCompLassen ion : falsch )

 

Jetzt bleibt nur noch der Soundeffekt während der Kollision des Helden mit dem Stern zu reproduzieren.

Ersetzen Sie in der collisionWithPlayer () -Methode der StarNode-Klasse selbst .removeFromParent () durch:

// Ton abspielen  runAction (starSound, Fertigstellung : { // Entferne diesen Stern  selbst .removeFromParent() })

 

Der Code startet SKAction, spielt die Sounddatei ab und entfernt den Stern, wenn die Aktion beendet ist.

Bauen und ausführen. Sobald das Sprite des Helden den Stern trifft, hören Sie ein Klingeln.

Spielobjekte: Plattformen

Unsere nächste Aufgabe ist es, eine Plattform hinzuzufügen. Wir werden eine neue Unterklasse der GameObjectNode-Klasse für die Plattformen erstellen. Wie bei den Sternen brauchen wir zwei Arten von Plattformen: Eine Art von Plattform muss unzerstörbar sein und die andere muss verschwinden, sobald der Held von ihnen springt.

Fügen Sie in GameObjectNode.swift die folgende Sammlung über der GameObjectNode-Klassendefinition hinzu, um zwei PlattformArt n zu definieren:

Aufzählung  PlatformType   : Int { Fall  Normal = 0 Fall  Brechen  }

 

Als Nächstes müssen wir eine PlatformNode -Klasse erstellen. Fügen Sie GameObjectNode.swift den folgenden Code hinzu:

class PlatformNode: GameObjectNode { var Plattformtyp : PlatformType! überschreiben  func collisionWithPlayer(player: SKNode) -> Bool { // 1 // Den Spieler nur abprallen lassen, wenn er fällt  if player.physicsBody? .velocity.dy <  0 { // 2 player.physicsBody? .velocity  = CGVector(dx: player.physicsBody!.velocity.dx, dy: 250,0 ) // 3 // Entfernen, wenn es sich um eine Break-Plattform handelt  if Plattformtyp  == .Brechen  { self.removeFromParent() } } // 4 // Keine Sterne für Plattformen  return falsch  } }

 

Schauen wir uns diesen Code genauer an:

1. In Übereinstimmung mit dem Spielszenario sollte der Knoten des Helden nur dann von der Plattform abprallen, wenn er fällt, dh wenn er einen negativen dy-Wert seiner Geschwindigkeit hat (Geschwindigkeitseigenschaft). Diese Überprüfung verhindert auch, dass der Heldenknoten die Plattformen überquert, wenn er sich auf dem Bildschirm nach oben bewegt.

2. Wir teilen dem Knoten des Helden eine Aufwärtsgeschwindigkeit mit, um von der Plattform abzuprallen. Dies geschieht auf die gleiche Weise wie zuvor für die Sterne, jedoch mit einem niedrigeren Wert. Die Sterne sind cooler, nicht wahr?

3. Wenn die Plattform vom Typ Plattform Type.Brechen ist, entfernen wir sie aus der Szene.

4. Der Ultra-Jumper erzielt keine Punkte, wenn er von der Plattform springt oder wenn er darauf springt, sodass das HUD nicht aktualisiert werden muss.

Um eine Plattform für die Szene hinzuzufügen, öffnen Sie GameScene.swift und geben Sie die folgende Methode ein:

func createPlatformAtPosition  (position: CGPoint, ofType-Typ : PlatformType) -> PlatformNode  { // 1 Lassen  node = PlatformNode() Lassen  thePosition = CGPoint(x: position.x  scaleFactor, y: position.y) node.position = thePosition node.name = "NODE_PLATFORM"  node.Plattform Type  = type // 2 var Sprite : SKSpriteNode if type == .Break { Sprite  = SKSpriteNode(imageNamed: "PlatformBreak" ) } sonst  { Sprite  = SKSpriteNode(imageNamed: "Plattform" ) } node.addChild(sprite) // 3 node.physicsBody = SKPhysicsBody(rechteckOfSize : sprite.size) node.physicsBody? .dynamic  = false node.physicsBody? .categoryBitMask  = CollisionCategoryBitmask.Platform node.physicsBody? .CollisionBitMask  = 0 return node }

 

Diese Methode ist createStarAtPosition (_: OfType 🙂 sehr ähnlich, beachten Sie jedoch die folgenden Hauptpunkte:

1. Wir erstellen eine Instanz von PlatformNode und legen deren Position, Namen und Typ fest.

2. Wählen Sie je nach Plattformtyp das entsprechende Image für SKSpriteNode aus.

3. Wir erstellen die Physik der Plattform, einschließlich der Art der Kollisionen.

Fügen Sie nun zum Hinzufügen einer Plattform den folgenden Code in die Methode init (size 🙂 ein, kurz vor der Zeile, in der der Stern erstellt wird:

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

 

Erstellen Sie das Spiel und führen Sie es aus. Klicken Sie hier, um zu starten und zu beobachten, wie der Hero Sprite vom Stern aus Energie erhält und dann auf der Plattform abprallt!

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

Wohin als nächstes?

Fein! Wie Sie sich vorstellen können, ist es nicht so schwierig, ein Spiel wie Mega Jump zu machen. Mit Uber Jump haben wir alle Grundlagen gelernt, die wir auf unserem Weg zu einem großartigen Spiel weiter anwenden können.

Am Ende des Artikels können Sie das Xcode-Projekt herunterladen, das alles enthält, was wir in diesem Kurs gelernt haben.

Im nächsten Teil werden wir den Beschleunigungsmesser verwenden, um die Bewegung des Helden entlang der X-Achse zu steuern. Außerdem werden wir eine Reihe von Eigenschaften aus einer externen Plist-Datei laden und ein Punktesystem hinzufügen. Viele interessante Dinge stehen noch bevor.

Wenn Sie Fragen, Gedanken oder Vorschläge für zukünftige Lektionen haben, hinterlassen Sie bitte unten Ihren Kommentar.

Fortsetzung in einer Woche ….

Laden Sie die Xcode-Quelle herunter.

Laden Sie grafische Ressourcen für die Lektion herunter.

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