Challenge 10: Crashy Bird

Challenge

Inspiriert von dem klassischen Spiel Flappy Bird ist es hier das Ziel, den Vogel durch die Hindernisse hindurch zu steuern.

Steuerung:

• A: nach oben
• B: nach unten
• A+B: Spiel starten

Das Hindernis wird mit einer zufällig durchlässigen Stelle am rechten Rand erstellt und bewegt sich dann schrittweise nach links. Das Sprite des Spielers bleibt immer am linken Rand und wird nach oben oder unten gesteuert. Man muss das Sprite so ausrichten, dass es durch das Hindernis passt. Je ausgewichenem Hindernis gibt es einen Punkt und die Geschwindigkeit der Hindernisse wird erhöht. Wenn man das Hindernis berührt, ist das Spiel vorbei und der erreichte Score soll ausgegeben werden.

Makecode

Programmierfunktion

• Variablen
• Arrays
• Events abfragen
• Funktionen
• While-Schleifen (endlos und mit Bedingung)
• For-Schleifen (mit Zähler und um Array-Elemente zu durchlaufen)

Spiellogik

Zu Beginn werden alle Variablen definiert und initialisiert. 

• Eine Variable die das Array für die Hindernisse speichert. Dieses ist zu Beginn leer.
• Eine Start-Variable, um zu speichern ob das Spiel läuft oder nicht. Sie steht anfangs auf True
• Eine Variable, um den Punktestand zu speichern
• Eine Variable, um die Anzahl der Ticks zu speichern. Ein Tick beschreibt die Zeit zwischen der Bewegung eines Hindernisses. Die Anzahl der vergangen Ticks benötigt man, um somit den Abstand der Hindernisse zu bestimmen. Diese sollte auf den Wert -1 speichern, da später im Code erst die Anzahl erhöht wird und dann das Hindernis erstellt und wenn man bei 0 anfangen würde somit das erste Hindernis zu früh erstellt werden würde.
• Zuletzt eine Sprite-Variable, welche den Vogel darstellen soll. Dieser wird mittig an den linken Rand gesetzt auf (0/2). Zur besseren Sichtbarkeit kann man das Sprite blinken lassen

Durch das gleichzeitige Drücken von „A“ und „B“ soll das Spiel gestartet werden. Nur wenn die Start-Variable auf True steht kann es gestartet werden. Sobald dies geschehen ist wird die Variable deshalb auf False gesetzt, um mehrmaliges Starten zu verhindern. Dann benötigt man eine Funktion. Diese kann bis jetzt noch leer sein und braucht keine Übergabeparameter. Der Aufruf dieser Funktion kommt unterhalb des Setzens der Start-Variable auf False.

Mit den Tasten „A“ und „B“ kann man jeweils einzeln dann den Vogel steuern. Mit „A“ wird die y-Koordinate um -1 geändert, bei „B“ um +1

Die erstellte Funktion beginnt mit einer endlosen while-Schleife. Dazu setzt man einfach ein True ein. Da die Bedingung der Schleife immer wahr ist, wird auch die Schleife immer ausgeführt. Zu Beginn wird die Anzahl der Ticks um 1 erhöht.

Ein neues Hindernis soll nur bei jedem 3. Tick entstehen. Dazu teilt man die Anzahl der Ticks durch 3 und fragt den Rest ab. Diesen Rest überprüft man in einer If-Abfrage ob er 0 ist und nur dann wird das Hindernis erstellt. Trotz dessen, dass die Anzahl der Ticks stetig höher wird kann man mit der Restdivision sich aushelfen. Da diese nur die Werte 0, 1, oder 2 auswerfen kann.

Für das Hindernis soll zuerst zufällig bestimmt werden, welcher Teil ausgelassen werden soll, durch den man dann hindurchfliegen kann. Dazu wird eine Zahl zwischen 0 und 4 ausgesucht. Diese zufällig ausgewählte y-Koordinate speichert man sich in einer Variablen. Als nächstes braucht man eine For-Schleife. Diese besitzt eine eingebaute Zähler-Variable und man kann bestimmen von und bis zu welchen Werten die Schleife zählen soll. Diese soll von 0 bis 4 zählen und kümmert sich um das Erstellen der einzelnen Elemente des Hindernisses. Nur dann, wenn die Zähler-Variable ungleich der zufälligen y-Koordinate, die leer bleiben soll, ist, dann wird dem Hindernis-Array am Ende ein Sprite hinzugefügt. Ein Hindernis startet immer auf der rechten Seite deshalb ist die x-Koordinate 4. Als y-Koordinate kann man die Zähler-Variable der Schleife einsetzen, da diese bei jedem Durchlauf automatisch um 1 erhöht wird, solange bis sie einen Grenzwert (hier: 4) erreicht hat.

Um ein Hindernis zu löschen braucht man erneut eine While-Schleife, welche aber noch Teil der ersten While-Schleife ist. Diese neue Schleife muss auch oberhalb der if-Abfrage eingebaut werden, da Hindernisse immer erst gelöscht werden sollen, bevor neue entstehen. Die Bedingung für die Schleife sieht so aus, dass die Länge des Arrays der Hindernis-Elemente größer als 0 und die x-Koordinate des ersten Hindernis-Elements auf Index 0 gleich 0 sein muss. Damit wird zum einen abgefragt, ob überhaupt schon ein Hindernis existiert und ob dieses sich am linken Rand befindet. Sind beide Bedingungen wahr soll das Hindernis-Element-Sprite von Index 0 genommen und gelöscht werden. Dies wird nun solange ausgeführt, bis alle vier Elemente des Hindernisses gelöscht wurden. An dieser Stelle lässt sich auch gleich die Logik für die Punktevergabe einbauen. Während des Spielverlaufs existieren gleichzeitig maximal zwei Hindernisse bzw. acht Hindernis-Elemente. Wenn man also während des Löschens feststellt, dass nurnoch vier Elemente vorhanden sind, weiß man, dass ein Hindernis entfernt wurde. Da ein Hindernis nur entfernt wird, wenn man es nicht vorher berührt hat, hat man auch einen Punkt verdient. Daher kann man in die While-Schleife unterhalb des Löschens der Hindernis-Elemente eine entsprechende If-Abfrage hinsetzen.

Unterhalb dieser While-Schleife und immer noch oberhalb des Erstellens der Hindernisse kommt nun die Bewegung von Hindernissen, da nur sich noch im Spiel befindliche sowie noch nicht erstellte Hindernisse weiterbewegen sollen. Dazu benötigt man eine For-Schleife, welche dieses Mal aber nicht mit einem Zähler arbeitet, sondern mit jedem einzelne Elemente innerhalb des Hindernis-Elemente Array. Diese soll die x-Koordinate jedes Hindernis-Element-Sprites innerhalb des Hindernis-Elemente-Arrays um -1 verändern.

So eine Schleife benötigt man dann unterhalb des Erstellens der Hindernisse noch einmal. Dieses Mal jedoch nicht um die Hindernis-Elemente zu bewegen, sondern mit Hilfe einer If-Abfrage zu überprüfen, ob eines der Hindernis-Elemente-Sprites das Sprite des Spielers berührt hat. Ist dies der Fall, ist das Spiel vorbei. Der Bildschirm soll geleert werden damit die erreichte Punktzahl angezeigt werden kann. Danach wartet man ein paar Sekunden und setzt das Programm zurück.

Unterhalb der For-Schleife benötigt man jetzt noch einen letzten wichtigen Block, und zwar die Berechnung der Wartezeit zwischen den Ticks. Der ganze Code innerhalb der großen äußeren While-Schleife ist für nur einen Schritt (Tick) des Spiels zuständig. Diese Wartezeit bestimmt also wie schnell das Spiel abgespielt wird. Als Startwert für die Pause ist eine Sekunde geeignet. Um das Spiel stetig schwieriger zu machen kann z.B. noch die erreichte Punktzahl um den Faktor zehn multiplizieren und von den 1000 Millisekunden abziehen.

Wir wünschen viel Spaß beim Austüfteln! Die Lösung zeigen wir morgen früh auf diesem Blog.