7 days of WordPress plugins, themes & templates - for free!* Unlimited asset downloads! Start 7-Day Free Trial
Advertisement
  1. Code
  2. SpriteKit

SpriteKit-Grundlagen: Aktionen und Physik

Scroll to top
Read Time: 22 mins
This post is part of a series called SpriteKit Basics.
SpriteKit Basics: Sprites
SpriteKit Basics: Putting It All Together

German (Deutsch) translation by Władysław Łucyszyn (you can also view the original English article)

In dieser Serie lernen wir, wie man SpriteKit verwendet, um 2D-Spiele für iOS zu erstellen. In diesem Beitrag lernen wir zwei wichtige Funktionen von SpriteKit kennen: Aktionen und Physik.

Um diesem Tutorial zu folgen, laden Sie einfach das zugehörige GitHub-Repository herunter. Es hat zwei Ordner: einen für Aktionen und einen für Physik. Öffnen Sie einfach eines der Starterprojekte in Xcode und Sie sind fertig.

Aktionen

In den meisten Spielen möchten Sie, dass Knoten etwas wie Verschieben, Skalieren oder Drehen tun. Zu diesem Zweck wurde die SKAction-Klasse entwickelt. Die SKAction-Klasse verfügt über viele Klassenmethoden, die Sie aufrufen können, um die Eigenschaften eines Knotens über einen bestimmten Zeitraum zu verschieben, zu skalieren oder zu drehen.

Sie können auch Sounds abspielen, eine Gruppe von Texturen animieren oder benutzerdefinierten Code mit der SKAction-Klasse ausführen. Sie können eine einzelne Aktion ausführen, zwei oder mehr Aktionen nacheinander in einer Sequenz ausführen, zwei oder mehr Aktionen gleichzeitig als Gruppe ausführen und sogar beliebige Aktionen wiederholen.

Bewegung

Lassen Sie uns einen Knoten über den Bildschirm bewegen. Geben Sie Folgendes in Example1.swift ein.

Hier erstellen wir eine SKAction und rufen die Klassenmethode moveTo(y:duration:) auf, die als Parameter die y-Position zum Verschieben des Knotens und die duration in Sekunden verwendet. Um die Aktion auszuführen, müssen Sie die Methode run(_:) eines Knotens aufrufen und die SKAction übergeben. Wenn Sie jetzt testen, sollten Sie ein Flugzeug sehen, das sich auf dem Bildschirm nach oben bewegt.

Es gibt verschiedene Arten von Verschiebemethoden, einschließlich move(to:duration:), wodurch der Knoten an eine neue Position sowohl auf der x- als auch auf der y-Achse verschoben wird, und move(by:duration:), wodurch ein Knoten relativ verschoben wird an seine aktuelle Position. Ich schlage vor, dass Sie die Dokumentation zu SKAction lesen, um mehr über alle Varianten der Verschiebemethoden zu erfahren.

Abschlussschließungen

Es gibt eine andere Variante der run-Methode, mit der Sie Code in einer Completion Closure aufrufen können. Geben Sie den folgenden Code in Example2.swift ein.

Mit der Methode run(_:completion:) können Sie einen Codeblock ausführen, sobald die Ausführung der Aktion vollständig abgeschlossen ist. Hier führen wir eine einfache print-Anweisung aus, aber der Code könnte so komplex sein, wie Sie es brauchen.

Aktionsfolgen

Manchmal möchten Sie Aktionen nacheinander ausführen, und Sie können dies mit der Methode sequence(_:) tun. Fügen Sie Example3.swift Folgendes hinzu.

Hier erstellen wir zwei SKActions: eine verwendet moveTo(y:duration:) und die andere verwendet scale(to:duration:), die die x- und y-Skala des Knotens ändert. Anschließend rufen wir die Methode sequence(_:) auf, die als Parameter ein Array von SKAction annimmt, die nacheinander ausgeführt werden sollen. Wenn Sie jetzt testen, sollten Sie sehen, wie sich das Flugzeug auf dem Bildschirm nach oben bewegt und sobald es sein Ziel erreicht hat, wird es auf das Dreifache seiner ursprünglichen Größe anwachsen.

Gruppierte Aktionen

Zu anderen Zeiten möchten Sie vielleicht Aktionen gemeinsam als Gruppe ausführen. Fügen Sie Example4.swift den folgenden Code hinzu.

Hier verwenden wir die gleichen moveTo- und scale-Methoden wie im vorherigen Beispiel, rufen aber auch die group(_:)-Methode auf, die als Parameter ein Array von SKAction verwendet, die gleichzeitig ausgeführt werden sollen. Wenn Sie jetzt testen würden, würden Sie sehen, dass sich das Flugzeug gleichzeitig bewegt und skaliert.

Umkehraktionen

Einige dieser Aktionen können durch Aufrufen der reversed()-Methode rückgängig gemacht werden. Der beste Weg, um herauszufinden, welche Aktionen die reversed()-Methode unterstützen, besteht darin, die Dokumentation zu konsultieren. Eine umkehrbare Aktion ist fadeOut(withDuration:), die einen Knoten unsichtbar macht, indem er seinen Alpha-Wert ändert. Lassen Sie uns das Flugzeug aus- und wieder einblenden. Fügen Sie Folgendes zu Example5.swift hinzu.

Hier erstellen wir eine SKAction und rufen die Methode fadeOut(withDuration:) auf. In der nächsten Codezeile rufen wir die Methode reversed() auf, wodurch die Aktion umgekehrt wird, was sie gerade getan hat. Testen Sie das Projekt und Sie werden sehen, wie das Flugzeug aus- und wieder einblendet.

Wiederholte Aktionen

Wenn Sie eine Aktion jemals eine bestimmte Anzahl von Malen wiederholen müssen, sind die Methoden repeat(_:count:) und repeatForever(_:) für Sie geeignet. Lassen Sie uns das Flugzeug immer wieder ausblenden und dann für immer wieder einblenden. Geben Sie den folgenden Code in Example6.swift ein.

Hier rufen wir die Methode repeatForever(_:) auf und übergeben die fadePlayerSequence. Wenn Sie testen, werden Sie sehen, dass das Flugzeug aus- und dann für immer wieder einblendet.

Aktionen stoppen

Oft müssen Sie einen Knoten daran hindern, seine Aktionen auszuführen. Dazu können Sie die Methode removeAllActions() verwenden. Lassen Sie uns den Player-Knoten aufhören zu verblassen, wenn wir den Bildschirm berühren. Fügen Sie in Example7.swift Folgendes hinzu.

Wenn Sie den Bildschirm berühren, werden alle Aktionen des Player-Knotens entfernt und nicht mehr ein- und ausgeblendet.

Nachverfolgen von Aktionen

Manchmal brauchen Sie eine Möglichkeit, Ihre Aktionen zu verfolgen. Wenn Sie beispielsweise zwei oder mehr Aktionen auf einem Knoten ausführen, möchten Sie möglicherweise eine Möglichkeit haben, diese zu identifizieren. Sie können dies tun, indem Sie beim Knoten einen Schlüssel registrieren, bei dem es sich um eine einfache Textzeichenfolge handelt. Geben Sie in der Datei Example8.swift Folgendes ein.

Hier rufen wir die Methode run(_:withKey:) des Knotens auf, die, wie bereits erwähnt, eine einfache Textzeichenfolge verwendet. Innerhalb der Methode touchesBegan(_:with:) rufen wir action(forKey:) auf, um sicherzustellen, dass der Knoten den von uns zugewiesenen Schlüssel hat. Wenn dies der Fall ist, rufen wir .removeAction(forKey:) auf, das als Parameter den zuvor festgelegten Schlüssel verwendet.

Soundaktionen

Oft möchten Sie etwas Sound in Ihrem Spiel spielen. Dies können Sie mit der Klassenmethode playSoundFileNamed(_:waitForCompletion:) erreichen. Geben Sie Folgendes in Example9.swift ein.

playSoundFileNamed(_:waitForCompletion:) verwendet als Parameter den Namen der Sounddatei ohne Erweiterung und einen booleschen Wert, der bestimmt, ob die Aktion wartet, bis der Sound abgeschlossen ist, bevor sie fortfährt.

Angenommen, Sie haben zwei Aktionen in einer Sequenz, wobei der Ton die erste Aktion ist. Wenn waitForCompletion true wäre, würde die Sequenz warten, bis die Wiedergabe des Sounds beendet ist, bevor sie zur nächsten Aktion innerhalb der Sequenz übergeht. Wenn Sie mehr Kontrolle über Ihre Sounds benötigen, können Sie einen SKAudioNode verwenden. Wir werden den SKAudioNode in dieser Serie nicht behandeln, aber es ist definitiv etwas, das Sie während Ihrer Karriere als SpriteKit-Entwickler in Betracht ziehen sollten.

Rahmenanimation

Das Animieren einer Gruppe von Bildern ist etwas, das viele Spiele erfordern. Das animate(with:timePerFrame:) hat Sie in diesen Fällen abgedeckt. Geben Sie Folgendes in Example10.swift ein.

Die animate(with:timePerFrame:) nimmt als Parameter ein Array von SKTexture und einen timePerFrame-Wert, der die Dauer zwischen den einzelnen Texturänderungen angeht. Um diese Aktion auszuführen, rufen Sie die run-Methode eines Knotens auf und übergeben die SKAction.

Benutzerdefinierte Codeaktionen

Der letzte Aktionstyp, den wir uns ansehen, ist eine Aktion, mit der Sie benutzerdefinierten Code ausführen können. Dies kann nützlich sein, wenn Sie mitten in Ihren Aktionen etwas tun müssen oder einfach nur eine Möglichkeit benötigen, etwas auszuführen, das die SKAction-Klasse nicht bereitstellt. Geben Sie Folgendes in Example11.swift ein.

Hier rufen wir die run(_:)-Methode der Szene auf und übergeben eine Funktion printToConsole() als Parameter. Denken Sie daran, dass Szenen auch Knoten sind, sodass Sie auch die Methode run(_:) für sie aufrufen können.

Damit ist unsere Aktionsstudie abgeschlossen. Es gibt eine Menge, die Sie mit der SKAction-Klasse tun können, und ich würde Ihnen nach dem Lesen dieses Tutorials vorschlagen, die Dokumentation zu SKActions weiter zu untersuchen.

Physik

SpriteKit bietet sofort eine robuste Physik-Engine, die nur wenig Setup erfordert. Um zu beginnen, fügen Sie einfach jedem Ihrer Knoten einen Physikkörper hinzu und schon können Sie loslegen. Die Physik-Engine baut auf der beliebten Box2d-Engine auf. Die API von SpriteKit ist jedoch viel einfacher zu verwenden als die ursprüngliche Box2d-API.

Beginnen wir damit, einen physikalischen Körper zu einem Knoten hinzuzufügen und zu sehen, was passiert. Fügen Sie Example1.swift den folgenden Code hinzu.

Fahren Sie fort und testen Sie das Projekt jetzt. Sie sehen das Flugzeug oben in der Szene. Sobald Sie auf den Bildschirm drücken, fällt das Flugzeug vom Bildschirm und wird für immer fallen. Dies zeigt, wie einfach es ist, mit der Physik zu beginnen – fügen Sie einfach einen physikalischen Körper zu einem Knoten hinzu und Sie sind fertig.

Die physicsBody-Form

Die Eigenschaft physicsBody ist vom Typ SKPhysicsBody, was eine grobe Kontur der Form Ihres Knotens... oder eine sehr genaue Kontur der Form Ihres Knotens ist, je nachdem, welchen Konstruktor Sie verwenden, um diese Eigenschaft zu initialisieren.

Hier haben wir den Initialisierer init(circleOfRadius:) verwendet, der als Parameter den Radius des Kreises verwendet. Es gibt mehrere andere Initialisierer, darunter einen für ein Rechteck oder ein Polygon aus einem CGPath. Sie können sogar die eigene Textur des Knotens verwenden, was den physicsBody zu einer nahezu exakten Darstellung des Knotens machen würde.

Um zu sehen, was ich meine, aktualisieren Sie die Datei GameViewController.swift mit dem folgenden Code. Ich habe die hinzuzufügende Zeile kommentiert.

Jetzt wird der physicsBody des Knotens grün umrandet. Bei der Kollisionserkennung wird die Form von physicsBody ausgewertet. In diesem Beispiel würde der Kreis um die Ebene die Kollisionserkennung führen, d. h. wenn beispielsweise eine Kugel auf den äußeren Rand des Kreises trifft, würde dies als Kollision gelten.

circle bodycircle bodycircle body

Fügen Sie nun Example2.swift Folgendes hinzu.

Hier verwenden wir die Textur des Sprites. Wenn Sie das Projekt jetzt testen, sollten Sie feststellen, dass sich der Umriss in eine nahezu exakte Darstellung der Textur des Sprites geändert hat.

texture bodytexture bodytexture body

Schwere

In den vorherigen Beispielen haben wir die Eigenschaft affectedByGravity von physicsBody auf false gesetzt. Sobald Sie einem Knoten einen Physikkörper hinzufügen, übernimmt die Physik-Engine. Das Ergebnis ist, dass das Flugzeug sofort abstürzt, wenn das Projekt ausgeführt wird!

Sie können die Schwerkraft auch auf Knotenbasis einstellen, wie hier, oder Sie können die Schwerkraft ganz deaktivieren. Fügen Sie Example3.swift Folgendes hinzu.

Wir können die Schwerkraft mit der Eigenschaft physicsWorld gravity einstellen. Die Eigenschaft gravity ist vom Typ CGVector. Wir setzen sowohl die dx- als auch die dy-Komponente auf 0, und wenn der Bildschirm berührt wird, setzen wir die dy-Eigenschaft auf -9.8. Die Komponenten werden in Metern gemessen und der Standardwert ist (0, -9.8), was die Schwerkraft der Erde darstellt.

Kantenschleifen

So wie es jetzt aussieht, fallen alle Knoten, die der Szene hinzugefügt werden, für immer vom Bildschirm. Wir können mit der Methode init(edgeLoopFrom:) eine Kantenschleife um die Szene herum hinzufügen. Fügen Sie Example4.swift Folgendes hinzu.

Hier haben wir der Szene selbst einen Physikkörper hinzugefügt. Das init(edgeLoopFrom:) nimmt als Parameter ein CGRect, das seine Kanten definiert. Wenn Sie jetzt testen, werden Sie feststellen, dass das Flugzeug immer noch fällt; es interagiert jedoch mit dieser Kantenschleife und fällt nicht mehr aus der Szene. Es springt auch und dreht sich sogar ein wenig auf die Seite. Das ist die Stärke der Physik-Engine – Sie erhalten all diese Funktionen kostenlos einsatzbereit. So etwas selbst zu schreiben wäre ziemlich komplex.

Sprungkraft

Wir haben gesehen, dass das Flugzeug aufprallt und sich auf die Seite dreht. Sie können die Sprungkraft steuern und ob der Physikkörper eine Drehung zulässt. Geben Sie Folgendes in Example5.swift ein.

Wenn Sie jetzt testen, werden Sie feststellen, dass der player sehr federnd ist und einige Sekunden braucht, um sich zu beruhigen. Sie werden auch feststellen, dass es sich nicht mehr dreht. Die Eigenschaft restitution nimmt eine Zahl von 0.0 (weniger Sprungkraft) bis 1.0 (sehr Sprungkraft) an, und die Eigenschaft allowsRotation ist ein einfacher boolescher Wert.

Reibung

In der realen Welt, wenn sich zwei Objekte gegeneinander bewegen, gibt es ein wenig Reibung zwischen ihnen. Sie können die Reibung eines physikalischen Körpers ändern – dies entspricht der „Rauheit“ des Körpers. Diese Eigenschaft muss zwischen 0,0 und 1,0 liegen. Der Standardwert ist 0,2. Fügen Sie Example6.swift Folgendes hinzu.

Hier erstellen wir ein rechteckiges Sprite und setzen die friction-Eigenschaft an seinem physicsBody auf 0.0. Wenn Sie jetzt testen, werden Sie sehen, dass das Flugzeug sehr schnell über das gedrehte Rechteck gleitet. Ändern Sie nun die Reibungseigenschaft auf 1.0 und testen Sie erneut. Sie werden sehen, dass das Flugzeug nicht ganz so schnell über das Rechteck gleitet. Das liegt an der Reibung. Wenn Sie möchten, dass es sich noch langsamer bewegt, können Sie dem physicsBody des player mehr Reibung verleihen (denken Sie daran, dass der Standardwert 0.2 ist).

Dichte und Masse

Es gibt ein paar andere Eigenschaften, die Sie am Physikkörper ändern können, z. B. Dichte und Masse. Die density- und mass-Eneigenschaften hängen zusammen, und wenn Sie eine ändern, wird die andere automatisch neu berechnet. Wenn Sie zum ersten Mal einen physikalischen Körper erstellen, wird die area-Eneigenschaft des Körpers berechnet und ändert sich danach nicht mehr (sie ist schreibgeschützt). Dichte und Masse basieren auf der Formel mass = density * area.

Wenn Sie mehr als einen Knoten in einer Szene haben, beeinflussen die Dichte und Masse die Simulation, wie die Knoten voneinander abprallen und interagieren. Denken Sie an einen Basketball und eine Bowlingkugel – sie haben ungefähr die gleiche Größe, aber eine Bowlingkugel ist viel dichter. Wenn sie kollidieren, ändert der Basketball die Richtung und Geschwindigkeit viel stärker als die Bowlingkugel.

Kraft und Impuls

Sie können Kräfte und Impulse anwenden, um den Physikkörper zu bewegen. Ein Impuls wird sofort und nur einmal angelegt. Eine Kraft hingegen wird normalerweise für eine kontinuierliche Wirkung aufgebracht. Die Kraft wird ab dem Zeitpunkt angewendet, an dem Sie die Kraft hinzufügen, bis der nächste Frame der Simulation verarbeitet wird. Um eine kontinuierliche Kraft aufzubringen, müssten Sie diese auf jeden Rahmen anwenden. Fügen Sie Example7.swift Folgendes hinzu.

Führen Sie das Projekt aus und warten Sie, bis der Player am unteren Bildschirmrand zur Ruhe kommt, und tippen Sie dann auf den Player. Sie werden sehen, wie der Spieler den Bildschirm hochfliegt und schließlich unten wieder zur Ruhe kommt. Wir geben einen Impuls mit der Methode applyImpulse(_:) an, die als Parameter einen CGVector verwendet und in Newton-Sekunden gemessen wird.

Warum nicht das Gegenteil versuchen und dem Spielerknoten eine Kraft hinzufügen? Denken Sie daran, dass Sie die Kraft kontinuierlich hinzufügen müssen, damit die gewünschte Wirkung erzielt wird. Ein guter Ort dafür ist die update(_:)-Methode der Szene. Sie können auch versuchen, die Rückgabeeigenschaft des Players zu erhöhen, um zu sehen, wie sich dies auf die Simulation auswirkt.

Kollisionserkennung

Die Physik-Engine verfügt über ein robustes Kollisions- und Kontakterkennungssystem. Standardmäßig können zwei beliebige Knoten mit physikalischen Körpern kollidieren. Sie haben dies in früheren Beispielen gesehen – es war kein spezieller Code erforderlich, um den Objekten mitzuteilen, dass sie interagieren sollen. Sie können dieses Verhalten jedoch ändern, indem Sie im Physikkörper eine "Kategorie" festlegen. Diese Kategorie kann dann verwendet werden, um zu bestimmen, welche Knoten miteinander kollidieren, und kann auch verwendet werden, um Sie zu informieren, wenn bestimmte Knoten Kontakt aufnehmen.

Der Unterschied zwischen einem Kontakt und einer Kollision besteht darin, dass ein Kontakt verwendet wird, um zu erkennen, wann sich zwei physikalische Körper berühren. Eine Kollision hingegen verhindert, dass sich zwei Physikkörper in den Raum des anderen kreuzen – wenn die Physik-Engine eine Kollision erkennt, setzt sie gegensätzliche Impulse aus, um die Objekte wieder auseinander zu bringen. Wir haben Kollisionen in Aktion mit dem Spieler und der Kantenschleife und dem Spieler und dem Rechteck aus den vorherigen Beispielen gesehen.

Arten der physicsBodies

Bevor wir mit dem Einrichten unserer Kategorien für die Physikkörper fortfahren, sollten wir über die Arten von physicsBodies sprechen. Dort sind drei:

  1. Ein dynamisches Volumen simuliert Objekte mit Volumen und Masse. Diese Objekte werden von Kräften und Kollisionen in der Physikwelt beeinflusst (z. B. das Flugzeug in vorherigen Beispielen).
  2. Ein statisches Volumen wird nicht durch Kräfte und Kollisionen beeinflusst. Da es jedoch selbst ein Volumen hat, können andere Körper davon abprallen und mit ihm interagieren. Sie legen die isDynamic-Eigenschaft des Physikkörpers auf false fest, um ein statisches Volumen zu erstellen. Diese Volumina werden nie von der Physik-Engine bewegt. Wir haben dies zuvor in Beispiel 6 in Aktion gesehen, wo das Flugzeug mit dem Rechteck interagierte, das Rechteck jedoch weder vom Flugzeug noch von der Schwerkraft beeinflusst wurde. Um zu sehen, was ich meine, gehen Sie zurück zu Beispiel 6 und entfernen Sie die Codezeile, die rectangle.physicsBody?.isDynamic = false festlegt.
  3. Der dritte physikalische Körpertyp ist eine edge, bei der es sich um einen statischen, volumenlosen Körper handelt. Wir haben diese Art von Körper in Aktion mit der Kantenschleife gesehen, die wir in allen vorherigen Beispielen um die Szene herum erstellt haben. Kanten interagieren mit anderen volumenbasierten Körpern, jedoch nie mit einer anderen Kante.

Die Kategorien verwenden eine 32-Bit-Ganzzahl mit 32 einzelnen Flags, die entweder ein- oder ausgeschaltet sein können. Das bedeutet auch, dass Sie nur maximal 32 Kategorien haben können. Dies sollte für die meisten Spiele kein Problem darstellen, aber es ist etwas zu beachten.

Kategorien erstellen

Erstellen Sie eine neue Swift-Datei, indem Sie auf Datei > Neu > Datei gehen und sicherstellen, dass Swift-Datei markiert ist.

New FileNew FileNew File

Geben Sie als Namen PhysicsCategories ein und klicken Sie auf Erstellen.

Physics CategoriesPhysics CategoriesPhysics Categories

Geben Sie Folgendes in die soeben erstellte Datei ein.

Wir verwenden eine Struktur PhysicsCategories, um Kategorien für Player, EdgeLoop und RedBall zu erstellen. Wir verwenden Bit-Shifting, um die Bits einzuschalten.

Geben Sie nun Folgendes in Example8.swift ein.

Hier erstellen wir wie gewohnt den player und erstellen zwei Variablen dx und dy, die als Komponenten eines CGVectors verwendet werden, wenn wir dem player einen Impuls geben.

Innerhalb von didMove(to:) richten wir den Player ein und fügen die categoryBitMaskcontactBitMask, und collisionBitMask hinzu. Die categoryBitMask sollte Sinn machen – dies ist der Player, also setzen wir ihn auf PhysicsCategories.Player. Uns interessiert, wann der Spieler mit dem redBall in Kontakt tritt, deshalb setzen wir die contactBitMask auf PhysicsCategories.RedBall. Schließlich möchten wir, dass es mit der Kantenschleife kollidiert und von dieser beeinflusst wird, also setzen wir die collisionBitMask auf PhysicsCategories.EdgeLoop. Schließlich setzen wir einen Impuls ein, um es in Bewegung zu setzen.

Auf dem redBall setzen wir einfach seine categoryBitMask. Mit dem edgeLoop setzen wir seine categoryBitMask, und weil wir daran interessiert sind, wann der player damit in Kontakt kommt, setzen wir seine contactBitMask.

Beim Einrichten von contactBitMask und collisionBitMask muss nur einer der Körper auf den anderen verweisen. Mit anderen Worten, Sie müssen nicht beide Körper so einrichten, dass sie sich berühren oder mit dem anderen kollidieren.

Für den edgeLoop stellen wir den Kontakt mit dem Spieler ein. Wir hätten den Player jedoch stattdessen so einrichten können, dass er mit dem edgeLoop interagiert, indem wir den bitweisen Operator oder (|) verwenden. Mit diesem Operator können Sie mehrere Kontakt- oder Kollisionsbitmasken einrichten. Zum Beispiel:

Um auf den Kontakt zweier Stellen reagieren zu können, müssen Sie das Protokoll SKPhysicsContactDelegate implementieren. Vielleicht haben Sie dies im Beispielcode bemerkt.

Um auf Kontaktereignisse zu reagieren, können Sie die Methoden didBegin(_:) und didEnd(_:) implementieren. Sie werden aufgerufen, wenn die beiden Objekte Kontakt aufgenommen haben bzw. wenn sie den Kontakt beendet haben. Wir bleiben bei der Methode didBegin(_:) für dieses Tutorial.

Hier ist noch einmal der Code für die Methode didBegin(_:).

Zuerst richten wir zwei Variablen firstBody und secondBody ein. Die beiden Körper im Parameter contact werden nicht in einer garantierten Reihenfolge übergeben, daher verwenden wir eine if-Anweisung, um zu bestimmen, welcher Körper eine niedrigere contactBitMask hat, und setzen diese auf firstBody.

Wir können jetzt überprüfen und sehen, welche physikalischen Körper Kontakt aufnehmen. Wir überprüfen, mit welchen physikalischen Körpern wir es zu tun haben, indem wir die categoryBitMask der Körper mit den zuvor eingerichteten PhysicsCategoriy verknüpfen (&&), und wenn das Ergebnis nicht Null ist, wissen wir, dass wir den richtigen Körper haben.

Schließlich drucken wir aus, welche Körper Kontakt aufnehmen. Wenn es der Player und edgeLoop waren, invertieren wir auch die dx- und dy-Eigenschaften und geben dem Player einen Impuls. Dadurch bleibt der Spieler ständig in Bewegung.

Damit ist unsere Studie zur Physik-Engine von SpriteKit abgeschlossen. Vieles wurde nicht behandelt, wie zum Beispiel SKPhysicsJoint. Die Physik-Engine ist sehr robust, und ich empfehle Ihnen dringend, alle verschiedenen Aspekte durchzulesen, beginnend mit SKPhysicBody.

Abschluss

In diesem Beitrag haben wir etwas über Aktionen und Physik gelernt – zwei sehr wichtige Teile des SpriteKit-Frameworks. Wir haben uns viele Beispiele angeschaut, aber es gibt immer noch viel, was man mit Aktionen und Physik machen kann, und die Dokumentation ist ein großartiger Ort zum Lernen.

Im nächsten und letzten Teil dieser Serie werden wir alles, was wir gelernt haben, in einem einfachen Spiel zusammenfassen. Danke fürs Lesen, und wir sehen uns dort!

Sehen Sie sich in der Zwischenzeit einige unserer umfassenden Kurse zur Swift- und SpriteKit-Entwicklung an!

Advertisement
Did you find this post useful?
Want a weekly email summary?
Subscribe below and we’ll send you a weekly email summary of all new Code tutorials. Never miss out on learning about the next big thing.
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.