German (Deutsch) translation by Katharina Grigorovich-Nevolina (you can also view the original English article)



Im vorherigen Teil dieser Serie haben wir die Eindringlinge in Bewegung versetzt, den Spieler und die Eindringlinge mit Geschossen beschossen und eine Kollisionserkennung durchgeführt. Im vierten und letzten Teil dieser Serie werden wir die Fähigkeit hinzufügen, den Spieler mit dem Beschleunigungsmesser zu bewegen, die Level zu verwalten und sicherzustellen, dass der Spieler stirbt, wenn er von einer Kugel getroffen wird. Lassen Sie uns anfangen.
1. Vollendung der Player
-Klasse
Schritt 1: Hinzufügen von Eigenschaften
Fügen Sie der Player
-Klasse unterhalb der canFire
-Eigenschaft die folgenden Eigenschaften hinzu.
private var invincible = false private var lives:Int = 3 { didSet { if(lives < 0){ kill() }else{ respawn() } } }
Die invincible
-Eigenschaft wird verwendet, um den Spieler vorübergehend unbesiegbar zu machen, wenn er ein Leben verliert. Die lives
-Eigenschaft ist die Anzahl der Leben, die der Spieler hat, bevor er getötet wird.
Wir verwenden die lives
-Eigenschaft in der lives-Eigenschaft, die jedes Mal aufgerufen wird, wenn ihr Wert festgelegt wird. Der didSet
-Beobachter wird unmittelbar nach dem Setzen des neuen Wertes der Eigenschaft aufgerufen. Auf diese Weise wird jedes Mal, wenn wir die lives
-Eigenschaft dekrementieren, automatisch überprüft, ob lives
kleiner als Null ist, und die kill
-Methode aufgerufen, wenn dies der Fall ist. Wenn der Spieler noch Leben hat, wird die respawn
-Methode aufgerufen. Property Beobachter sind sehr praktisch und können eine Menge zusätzlichen Code speichern.
Schritt 2: respawn
Die respawn
-Methode macht den Spieler für kurze Zeit unbesiegbar und blendet den Spieler ein und aus, um anzuzeigen, dass er vorübergehend unbesiegbar ist. Die Implementierung der respawn
-Methode sieht folgendermaßen aus:
func respawn(){ invincible = true let fadeOutAction = SKAction.fadeOutWithDuration(0.4) let fadeInAction = SKAction.fadeInWithDuration(0.4) let fadeOutIn = SKAction.sequence([fadeOutAction,fadeInAction]) let fadeOutInAction = SKAction.repeatAction(fadeOutIn, count: 5) let setInvicibleFalse = SKAction.runBlock(){ self.invincible = false } runAction(SKAction.sequence([fadeOutInAction,setInvicibleFalse])) }
Wir setzen invincible
auf true
und erstellen eine Reihe von SKAction
-Objekten. Jetzt sollten Sie mit der Funktionsweise der SKAction
-Klasse vertraut sein.
Schritt 3: die
Die die
-Methode ist ziemlich einfach. Es überprüft, ob invicible
ist false
und, wenn es ist, dekrementiert die lives
Variable.
func die (){ if(invincible == false){ lives -= 1 } }
Schritt 4: kill
Die kill
-Methode setzt invaderNum
auf 1 zurück und bringt den Benutzer zurück zum StartGameScene, um ein neues Spiel zu beginnen.
func kill(){ invaderNum = 1 let gameOverScene = StartGameScene(size: self.scene!.size) gameOverScene.scaleMode = self.scene!.scaleMode let transitionType = SKTransition.flipHorizontalWithDuration(0.5) self.scene!.view!.presentScene(gameOverScene,transition: transitionType) }
Dieser Code sollte Ihnen vertraut sein, da er fast identisch mit dem Code ist, den wir verwendet haben, um vom StartGameScene zum GameScene zu gelangen. Beachten Sie, dass wir die scene
auspacken müssen, um auf die size
- und scaleMode
-Eigenschaften der Szene zuzugreifen.
Das schließt die Player
-Klasse ab. Wir müssen nun die Methoden die
und kill
in der Methode didBeginContact(_:)
aufrufen.
func didBeginContact(contact: SKPhysicsContact) { ... if ((firstBody.categoryBitMask & CollisionCategories.Player != 0) && (secondBody.categoryBitMask & CollisionCategories.InvaderBullet != 0)) { player.die() } if ((firstBody.categoryBitMask & CollisionCategories.Invader != 0) && (secondBody.categoryBitMask & CollisionCategories.Player != 0)) { player.kill() } }
Wir können jetzt alles testen. Eine schnelle Methode zum Testen der die
-Methode besteht darin, den moveInvaders
-Aufruf in der update(_:)
-Methode auszukommentieren. Nachdem der Spieler drei Mal gestorben und neu geparkt hat, solltest du zurück zum StartGameScene gebracht werden.
Stellen Sie zum Testen der kill
-Methode sicher, dass der Aufruf von moveInvaders
nicht auskommentiert ist. Setzen Sie die Eigenschaft invaderSpeed
auf einen hohen Wert, z. B. 200. Die Angreifer sollten den Player sehr schnell erreichen, was zu einem sofortigen Abbruch führt. Ändern Sie nach dem Testen die Geschwindigkeit von inaderSpeed
zurück auf 2.
2. Vollendung der Erschießung von Eindringlingen
Während das Spiel gerade steht, kann nur die untere Reihe der Eindringlinge Kugeln abfeuern. Wir haben bereits die Kollisionserkennung für den Fall, dass eine Spielerkugel einen Eindringling trifft. In diesem Schritt entfernen wir einen Eindringling, der von einer Kugel getroffen wird, und fügen den Eindringling eine Reihe hoch zu der Gruppe von Eindringlingen, die feuern können. Fügen Sie der Methode didBeginContact(_:)
Folgendes hinzu.
func didBeginContact(contact: SKPhysicsContact) { ... if ((firstBody.categoryBitMask & CollisionCategories.Invader != 0) && (secondBody.categoryBitMask & CollisionCategories.PlayerBullet != 0)){ if (contact.bodyA.node?.parent == nil || contact.bodyB.node?.parent == nil) { return } let invadersPerRow = invaderNum * 2 + 1 let theInvader = firstBody.node? as Invader let newInvaderRow = theInvader.invaderRow - 1 let newInvaderColumn = theInvader.invaderColumn if(newInvaderRow >= 1){ self.enumerateChildNodesWithName("invader") { node, stop in let invader = node as Invader if invader.invaderRow == newInvaderRow && invader.invaderColumn == newInvaderColumn{ self.invadersWhoCanFire.append(invader) stop.memory = true } } } let invaderIndex = findIndex(invadersWhoCanFire,valueToFind: firstBody.node? as Invader) if(invaderIndex != nil){ invadersWhoCanFire.removeAtIndex(invaderIndex!) } theInvader.removeFromParent() secondBody.node?.removeFromParent() } }
Wir haben die NSLog
-Anweisung entfernt und zuerst überprüft, ob contact.bodyA.node?.parent
und contact.bodyB.node?.parent
nicht nil
sind. Sie werden nil
sein, wenn wir diesen Kontakt bereits bearbeitet haben. In diesem Fall kehren wir von der Funktion zurück.
Wir berechnen die invadersPerRow
wie zuvor und setzen theInvader
auf firstBody.node?
, um ihn in einen Invader
zu verwandeln. Als nächstes erhalten wir den newInvaderRow
durch Subtraktion von 1 und die newInvaderColumn
, die gleich bleibt.
Wir wollen Eindringlinge nur feuern lassen, wenn newInvaderRow
größer oder gleich 1 ist. Andernfalls würden wir versuchen, einen Eindringling in Zeile 0 zu setzen, um feuern zu können. Es gibt keine Zeile 0, das würde zu einem Fehler führen.
Als nächstes zählen wir durch die Eindringlinge und suchen nach dem Eindringling, der die richtige Zeile und Spalte hat. Sobald es gefunden ist, hängen wir es an das Array invadersWhoCanFire
an und rufen stop.memory
auf true
auf, damit die Enumeration vorzeitig stoppt.
Wir müssen den Eindringlinge finden, der im Array InvadersWhoCanFire
mit einer Kugel getroffen wurde, damit wir ihn entfernen können. Normalerweise haben Arrays eine Art von Funktionalität wie eine indexOf
-Methode oder etwas Ähnliches, um das zu erreichen. Zum Zeitpunkt des Schreibens gibt es keine solche Methode für Arrays in der Swift-Sprache. Die Swift-Standardbibliothek definiert eine find
-Funktion, die wir verwenden könnten, aber ich habe eine Methode in den Abschnitten zu Generika im Swift-Programmiersprachen-Handbuch gefunden, die das erreichen, was wir brauchen. Die Funktion hat den passenden Namen findIndex
. Fügen Sie am Ende von GameScene.swift Folgendes hinzu.
func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? { for (index, value) in enumerate(array) { if value == valueToFind { return index } } return nil }
Wenn Sie neugierig sind, wie diese Funktion funktioniert, dann empfehle ich Ihnen, mehr über Generika im Swift Programming Language Guide zu lesen.
Nun, da wir eine Methode haben, mit der wir den Eindringling finden können, rufen wir ihn auf und übergeben das invadersWhoCanFire
-Array und theInvader
. Wir prüfen, ob invaderIndex
nicht gleich nil
ist und entfernen den Eindringlinge aus dem Array invadersWhoCanFire
mit der Methode removeAtIndex (index: Int)
.
Sie können jetzt testen, ob es so funktioniert, wie es sollte. Ein einfacher Weg wäre, den Aufruf von player.die
in der Methode didBeginContact(_:)
zu kommentieren. Stellen Sie sicher, dass Sie den Kommentar entfernen, wenn Sie mit dem Testen fertig sind. Beachten Sie, dass das Programm abstürzt, wenn Sie alle Eindringlinge töten. Wir werden das im nächsten Schritt beheben.
Die Anwendung stürzt ab, weil wir einen SKAction
repeatActionForever(_:)
haben, der Angreifer dazu aufruft, Kugeln zu feuern. Zu diesem Zeitpunkt gibt es keine Eindringlinge mehr, die Kugeln abfeuern könnten, so dass die Spiele abstürzen. Wir können das beheben, indem wir die isEmpty
-Eigenschaft im Array invadersWhoCanFire
überprüfen. Wenn das Array leer ist, ist das Level beendet. Geben Sie in der Methode fireInvaderBullet
Folgendes ein.
func fireInvaderBullet(){ if(invadersWhoCanFire.isEmpty){ invaderNum += 1 levelComplete() }else{ let randomInvader = invadersWhoCanFire.randomElement() randomInvader.fireBullet(self) } }
Die Stufe ist komplett, was bedeutet, dass wir invaderNum
erhöhen, was für die Stufe verwendet wird. Wir rufen auch levelComplete
auf, das wir noch in den kommenden Schritten erstellen müssen.
3. Eine Stufe abschließen
Wir brauchen eine bestimmte Anzahl von Ebenen. Wenn wir das nicht tun, werden wir nach mehreren Runden so viele Eindringlinge haben, dass sie nicht auf den Bildschirm passen. Fügen Sie der GameScene
-Klasse eine Eigenschaft maxLevels
hinzu.
class GameScene: SKScene, SKPhysicsContactDelegate{ ... let player:Player = Player() let maxLevels = 3
Fügen Sie nun die levelComplete
-Methode am unteren Rand von GameScene.swift hinzu.
func levelComplete(){ if(invaderNum <= maxLevels){ let levelCompleteScene = LevelCompleteScene(size: size) levelCompleteScene.scaleMode = scaleMode let transitionType = SKTransition.flipHorizontalWithDuration(0.5) view?.presentScene(levelCompleteScene,transition: transitionType) }else{ invaderNum = 1 newGame() } }
Wir überprüfen zunächst, ob invaderNum
kleiner oder gleich den von uns festgelegten maxLevels
ist. Wenn dies der Fall ist, gehen wir zu LevelCompletScene über, andernfalls setzen wir invaderNum
auf 1 zurück und rufen newGame
auf. LevelCompleteScene existiert noch nicht, und die newGame
-Methode lässt sich in den nächsten zwei Schritten nicht einzeln angehen.
4. Implementieren der LevelCompleteScene
-Klasse
Erstellen Sie eine neue Cocoa Touch-Klasse namens LevelCompleteScene, die eine Unterklasse von SKScene
ist. Die Implementierung der Klasse sieht folgendermaßen aus:
import Foundation import SpriteKit class LevelCompleteScene:SKScene{ override func didMoveToView(view: SKView) { self.backgroundColor = SKColor.blackColor() let startGameButton = SKSpriteNode(imageNamed: "nextlevelbtn") startGameButton.position = CGPointMake(size.width/2,size.height/2 - 100) startGameButton.name = "nextlevel" addChild(startGameButton) } override func touchesBegan(touches: NSSet, withEvent event: UIEvent) { /* Called when a touch begins */ for touch: AnyObject in touches { let touchLocation = touch.locationInNode(self) let touchedNode = self.nodeAtPoint(touchLocation) if(touchedNode.name == "nextlevel"){ let gameOverScene = GameScene(size: size) gameOverScene.scaleMode = scaleMode let transitionType = SKTransition.flipHorizontalWithDuration(0.5) view?.presentScene(gameOverScene,transition: transitionType) } } } }
Die Implementierung ist identisch mit der StartGameScreen
-Klasse, außer dass wir die name
-Eigenschaft von startGameButton
auf "nextlevel"
setzen. Dieser Code sollte Ihnen vertraut sein. Wenn nicht, dann kehren Sie zum ersten Teil dieses Tutorials für eine Auffrischung zurück.
5. newGame
Die Methode newGame
wechselt einfach zurück zum StartGameScene. Fügen Sie am Ende von GameScene.swift Folgendes hinzu.
func newGame(){ let gameOverScene = StartGameScene(size: size) gameOverScene.scaleMode = scaleMode let transitionType = SKTransition.flipHorizontalWithDuration(0.5) view?.presentScene(gameOverScene,transition: transitionType) }
Wenn Sie die Anwendung testen, können Sie ein paar Stufen spielen oder ein paar Spiele verlieren, aber der Spieler hat keine Möglichkeit sich zu bewegen und das macht ein langweiliges Spiel. Lassen Sie uns das im nächsten Schritt beheben.
6. Verschieben des Spielers mit dem Beschleunigungssensor
Wir werden den Beschleunigungsmesser benutzen, um den Spieler zu bewegen. Zuerst müssen wir das CoreMotion-Framework importieren. Fügen Sie eine Importanweisung für das Framework oben in GameScene.swift hinzu.
import SpriteKit import CoreMotion
Wir brauchen auch ein paar neue Eigenschaften.
let maxLevels = 3 let motionManager: CMMotionManager = CMMotionManager() var accelerationX: CGFloat = 0.0
Als nächstes fügen Sie am unteren Rand von GameScene.swift eine Methode setupAccelerometer
hinzu.
func setupAccelerometer(){ motionManager.accelerometerUpdateInterval = 0.2 motionManager.startAccelerometerUpdatesToQueue(NSOperationQueue.currentQueue(), withHandler: { (accelerometerData: CMAccelerometerData!, error: NSError!) in let acceleration = accelerometerData.acceleration self.accelerationX = CGFloat(acceleration.x) }) }
Hier setzen wir den accelerometerUpdateInterval
, das ist das Intervall in Sekunden für die Bereitstellung von Updates für den Handler. Ich fand 0.2 funktioniert gut, Sie können verschiedene Werte ausprobieren, wenn Sie es wünschen. Innerhalb des Handlers; ein Abschluss, erhalten wir die accelerometerData.acceleration
, die eine Struktur vom Typ CMAcceleration
ist.
struct CMAcceleration { var x: Double var y: Double var z: Double init() init(x x: Double, y y: Double, z z: Double) }
Wir sind nur an der x
-Eigenschaft interessiert und verwenden die numerische Typkonvertierung, um sie für unsere accelerationX
-Eigenschaft in einen CGFloat
umzuwandeln.
Jetzt, da wir die accelerationX
-Eigenschaft festgelegt haben, können wir den Player verschieben. Das machen wir in der Methode didSimulatePhysics
. Fügen Sie am Ende von GameScene.swift Folgendes hinzu.
override func didSimulatePhysics() { player.physicsBody?.velocity = CGVector(dx: accelerationX * 600, dy: 0) }
Rufen Sie setupAccelerometer
in didMoveToView(_:)
auf und Sie sollten den Player mit dem Beschleunigungssensor bewegen können. Es gibt nur ein Problem. Der Spieler kann sich außerhalb des Bildschirms zu beiden Seiten bewegen und es dauert ein paar Sekunden, um ihn zurück zu bekommen. Wir können das beheben, indem wir die Physik-Engine und Kollisionen verwenden. Wir machen das im nächsten Schritt.
override func didMoveToView(view: SKView) { ... setupInvaders() setupPlayer() invokeInvaderFire() setupAccelerometer() }
7. Beschränken der Bewegung des Spielers
Wie im vorherigen Schritt erwähnt, kann sich der Spieler außerhalb des Bildschirms bewegen. Das ist ein einfacher Fehler, der die Physik-Engine von Sprite Kit verwendet. Fügen Sie zuerst eine neue CollisionCategory
namens EdgeBody
hinzu.
struct CollisionCategories{ static let Invader : UInt32 = 0x1 << 0 static let Player: UInt32 = 0x1 << 1 static let InvaderBullet: UInt32 = 0x1 << 2 static let PlayerBullet: UInt32 = 0x1 << 3 static let EdgeBody: UInt32 = 0x1 << 4 }
Setzen Sie das als collisionBitMask
des Spielers in seiner init
-Methode.
override init() { ... self.physicsBody?.categoryBitMask = CollisionCategories.Player self.physicsBody?.contactTestBitMask = CollisionCategories.InvaderBullet | CollisionCategories.Invader self.physicsBody?.collisionBitMask = CollisionCategories.EdgeBody animate() }
Zuletzt erstellen wir einen PhysikBody
in der Szene selbst. Fügen Sie der Methode didMoveToView(view:SKView)
in GameScene.swift Folgendes hinzu:
override func didMoveToView(view: SKView) { self.physicsWorld.gravity=CGVectorMake(0, 0) self.physicsWorld.contactDelegate = self self.physicsBody = SKPhysicsBody(edgeLoopFromRect: frame) self.physicsBody?.categoryBitMask = CollisionCategories.EdgeBody }
Wir initialisieren einen Physikkörper, indem wir init(edgeLoopFromRect:)
aufrufen und frame
der Szene übergeben. Der Initialisierer erzeugt eine Kantenschleife aus dem Rahmen der Szene. Es ist wichtig zu beachten, dass eine Kante kein Volumen oder Masse hat und immer so behandelt wird, als wäre die dynamische Eigenschaft gleich false
. Kanten können auch nur mit volumenbasierten Physikkörpern kollidieren, die unser Player ist.
Wir setzen die categoryBitMask
auch auf CollisionCategories.EdgeBody
. Wenn Sie die Anwendung testen, stellen Sie möglicherweise fest, dass sich Ihr Schiff nicht mehr außerhalb des Bildschirms bewegen kann, aber manchmal dreht es sich. Wenn ein Physikkörper mit einem anderen Physikkörper kollidiert, kann das zu einer Rotation führen. Das ist das Standardverhalten. Um das zu beheben, setzen wir in Player.swift allowsRotation
auf false
.
override init() { ... self.physicsBody?.collisionBitMask = CollisionCategories.EdgeBody self.physicsBody?.allowsRotation = false animate() }
8. Sternfeld
Schritt 1: Erstellen des Sternfeldes
Das Spiel hat ein bewegliches Sternenfeld im Hintergrund. Wir können das Startfeld mit der Partikel-Engine von Sprite Kit erstellen.
Erstellen Sie eine neue Datei und wählen Sie Ressource aus dem Bereich iOS. Wählen Sie SpriteKit Particle File als Vorlage und klicken Sie auf Weiter. Wählen Sie für die Partikelvorlage Regen und speichern Sie sie als StarField. Klicken Sie auf Erstellen, um die Datei im Editor zu öffnen. Um die Optionen zu sehen, öffnen Sie den SKNode Inspector auf der rechten Seite.



Anstatt jede Einstellung hier zu durchlaufen, was lange dauern würde, wäre es besser, die Dokumentation zu lesen, um sich über jede einzelne Einstellung zu informieren. Ich werde auch nicht auf die Einstellungen des Startfelds eingehen. Wenn Sie interessiert sind, öffnen Sie die Datei in Xcode und sehen Sie sich die Einstellungen an, die ich verwendet habe.
Schritt 2: Hinzufügen des Sternfeldes zu den Szenen
Fügen Sie Folgendes zu didMoveToView(_:)
in StartGameScene.swift hinzu.
override func didMoveToView(view: SKView) { backgroundColor = SKColor.blackColor() let starField = SKEmitterNode(fileNamed: "StarField") starField.position = CGPointMake(size.width/2,size.height/2) starField.zPosition = -1000 addChild(starField) }
Wir verwenden einen SKEmitterNode
, um die StarField.sks-Datei zu laden, ihre position
festzulegen und ihr eine niedrige zPosition
zu geben. Der Grund für die niedrige zPosition
ist, dass der Benutzer nicht daran gehindert wird, auf die Startschaltfläche zu tippen. Das Partikelsystem erzeugt Hunderte von Partikeln, und indem wir es wirklich niedrig setzen, überwinden wir dieses Problem. Sie sollten auch wissen, dass Sie alle Partikeleigenschaften auf einem SKEmitterNode
manuell konfigurieren können, obwohl es viel einfacher ist, den Editor zu verwenden, um eine .sks-Datei zu erstellen, und es zur Laufzeit zu laden.
Fügen Sie jetzt das Sternfeld zu GameScene.swift und LevelCompleteScene.swift hinzu. Der Code ist genau der gleiche wie oben.
9. Implementieren der PulsatingText
-Klasse
Schritt 1: Erstellen Sie die PulsatingText
-Klasse
Die StartGameScene und LevelCompleteScene haben Text, der wiederholt wächst und schrumpft. Wir werden SKLabeNode
ableiten und einige SKAction
-Instanzen verwenden, um diesen Effekt zu erzielen.
Erstellen Sie eine neue Cocoa Touch-Klasse, die eine Unterklasse von SKLabelNode
ist, nennen Sie sie PulsatingText, und fügen Sie den folgenden Code hinzu.
import UIKit import SpriteKit class PulsatingText : SKLabelNode { func setTextFontSizeAndPulsate(theText: String, theFontSize: CGFloat){ self.text = theText; self.fontSize = theFontSize let scaleSequence = SKAction.sequence([SKAction.scaleTo(2, duration: 1),SKAction.scaleTo(1.0, duration:1)]) let scaleForever = SKAction.repeatActionForever(scaleSequence) self.runAction(scaleForever) } }
Eines der ersten Dinge, die Sie vielleicht bemerkt haben, ist, dass es keinen Initialisierer gibt. Wenn Ihre Unterklasse keinen designierten Initialisierer definiert, erbt sie automatisch alle ihre Initialen, die als Superklassen bezeichnet werden.ders.
Wir haben eine Methode setTextFontSizeAndPulsate (theText:theFontSize:)
, die genau das tut, was sie sagt. Er legt die SKLabelNode
-Eigenschaften text
und fontSize
fest und erstellt eine Reihe von SKAction
-Instanzen, um den Text hoch- und dann wieder abwärts zu stellen, wodurch ein pulsierender Effekt entsteht.
Schritt 2: Fügen Sie PulsatingText
zu StartGameScene
hinzu
Fügen Sie zu StartGameScene.swift in didMoveToView(_:)
den folgenden Code hinzu.
override func didMoveToView(view: SKView) { backgroundColor = SKColor.blackColor() let invaderText = PulsatingText(fontNamed: "ChalkDuster") invaderText.setTextFontSizeAndPulsate("INVADERZ", theFontSize: 50) invaderText.position = CGPointMake(size.width/2,size.height/2 + 200) addChild(invaderText) }
Wir initialisieren eine PulsatingText
-Instanz, invaderText
, und rufen setTextFontSizeAndPulsate (theText:theFontSize:)
darauf auf. Wir setzen dann seine position
und fügen sie der Szene hinzu.
Schritt 3: Fügen Sie PulsatingText
zu LevelCompleteScene
hinzu
Fügen Sie LevelCompleteScene.swift in didMoveToView(_:)
den folgenden Code hinzu.
override func didMoveToView(view: SKView) { self.backgroundColor = SKColor.blackColor() let invaderText = PulsatingText(fontNamed: "ChalkDuster") invaderText.setTextFontSizeAndPulsate("LEVEL COMPLETE", theFontSize: 50) invaderText.position = CGPointMake(size.width/2,size.height/2 + 200) addChild(invaderText) }
Das ist genau das Gleiche wie im vorherigen Schritt. Nur der Text, den wir passieren, ist an
10. Das Spiel weiterführen
Das vervollständigt das Spiel. Ich habe einige Vorschläge, wie Sie das Spiel weiter ausbauen können. Im Bilderordner befinden sich drei verschiedene Eindringlingsbilder. Wenn Sie der Szene Eindringlinge hinzufügen, wählen Sie nach dem Zufallsprinzip eines dieser drei Bilder aus. Sie müssen den Initialisierer des Eindringlings aktualisieren, um ein Bild als Parameter zu akzeptieren. Einen Hinweis finden Sie in der Bullet
-Klasse.
Es gibt auch ein UFO-Bild. Versuchen Sie, das etwa alle fünfzehn Sekunden anzuzeigen und sich über den Bildschirm zu bewegen. Wenn der Spieler es trifft, geben Sie ihm ein zusätzliches Leben. Vielleicht möchten Sie die Anzahl der Leben begrenzen, die sie haben können, wenn Sie dies tun. Versuchen Sie schließlich, ein HUD für die Spieler zu erstellen.
Das sind nur einige Vorschläge. Versuchen Sie das Spiel zu Ihrem eigenen zu machen.
Schlussfolgerung
Damit schließt sich diese Serie. Sie sollten ein Spiel haben, das dem ursprünglichen Weltraum-Eindringlinge-Spiel sehr ähnlich ist. Ich hoffe, Sie haben dieses Tutorial hilfreich gefunden und etwas Neues gelernt. Danke fürs Lesen.
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.
Update me weekly