Challenge 11: Hürdenlauf

Challenge

In diesem Spiel geht es darum rechtzeitig über die Hürden zu springen. In der linken unteren Ecke steht der Spieler bzw. Hürdenläufer. Die Hürden haben verschiedene Höhen und bewegen sich auf ihn zu. Durch Drücken auf die „B“ Taste springt er. Je übersprungener Hürde gibt es einen Punkt und die Geschwindigkeit der Hürden wird erhöht. Wenn man die Hürde berührt, ist das Spiel vorbei und der erreichte Score soll ausgegeben werden.

Tipps:

• Große Teile des Codes können von Crashy Bird übernommen werden. Lediglich Variablen, die Logik und die Steuerung müssen angepasst werden. Die Art und Weise wie Hürden generiert, bewegt und gelöscht werden ist dieselbe.
• Die Höhe der Hürden hat keinen Einfluss auf die Steuerung. Die Taste muss nicht öfter gedrückt werden oder dergleichen. Jedoch ist es wichtig, wann man die Taste drückt. Je höher die Hürde desto schwieriger.

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 Hürden 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 zu speichern, ob die Taste „B“ gedrückt wurde oder nicht. Sie steht anfangs auf False.
• Jeweils eine Variable für die Sprunggeschwindigkeit des Spielers sowie die Geschwindigkeit mit der sich die Hürden bewegen sollen. Geeignete Startwerte sind 80 Millisekunden für den Spieler und 500 Millisekunden für die Hürden.
• 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 Spieler darstellen soll. Dieser wird in die untere linke Ecke gesetzt auf (0/4). 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 der „B“ Taste soll man springen können. Um mehrmaliges springen zu verhindern wird mit einer If-Abfrage geprüft ob die entsprechende Variable auf False steht. Dazu wird der der Wert, welcher in dieser Variablen gespeichert ist umgekehrt abgefragt. Mit einem „not“ wird aus dem False in der Variable logisch ein True und der Code wird ausgeführt. Dort wird die Variable jetzt tatsächlich auf True gesetzt. Würde man jetzt erneut drücken wird das True logisch umgekehrt in ein False und der Code nicht ausgeführt.

Mit Hilfe einer Endlosschleife wird das Springen des Spielers gehändelt. Zuerst wird abgefragt, ob die „B“ Taste gedrückt wurde, also die entsprechende Variable auf True steht. Danach wird wiederholt vier Mal die y-Koordinate des Spielers um -1 verändert und dann um die gespeicherte Zeit in der Sprunggeschwindigkeits-Variablen gewartet. Hiermit springt der Spieler also nach oben. Oben angekommen soll dann um die zweifache Sprunggeschwindigkeit gewartet werden, als eine Art Momentum und damit der Spieler nicht ruckartig wieder zurückfällt. Das Herunterfallen funktioniert dann gleich wie das Hochspringen nur das jetzt die y-Koordinate um +1 verändert wird. Am Ende soll die Variable, welche speichert ob die „B“ Taste gedrückt wurde wieder auf False gesetzt werden, da der Spieler wieder am Boden angekommen ist und erneut springen darf.

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.

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

Für die Hürde soll zuerst zufällig bestimmt werden, wie hoch diese werden soll. Dazu wird eine Zahl zwischen 1 und 4 ausgesucht. Diese zufällig ausgewählte Höhe 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 zu der ausgesuchten Höhe zählen, wobei man von der Höhe 1 abziehen muss, da die Zählung bei null beginnt. Die Schleife kümmert sich um das Erstellen der einzelnen Elemente der Hürden. Dazu wird dem Hürden-Array bei jedem Schleifendurchlauf ein neues Hürden-Element-Sprite ans Ende hinzugefügt. Die Hürden sollen auf der rechten Seite auftauchen daher bekommen sie als x-Koordinate 4. Um jetzt die Hürden entsprechend der ausgewählten Höhe zu erstellen, wird von der y-Koordinate bei jedem Durchlauf der aktuelle Zählerstand abgezogen. Auch diese startet mit y=4. Hier ist es hilfreich, dass die Zählung bei null beginnt, da so bei einer Hürde die 1 hoch ist auch wirklich nur ein Hürdenelement auf Position y=4 bekommt. 

Um eine Hürde 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 Hürden 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 Hürden-Elemente größer als 0 und die x-Koordinate des ersten Hürden-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 Hürden-Element-Sprite von Index 0 genommen und gelöscht werden. Dies wird nun solange ausgeführt, bis alle Elemente der Hürde gelöscht wurden. An dieser Stelle lässt sich auch gleich die Logik für die Punktevergabe einbauen. Innerhalb der Schleife lässt man am Ende eine Variable auf True setzen. Nachdem die Hürden vollständig gelöscht wurde fragt man direkt danach unterhalb der Schleife mit einer If-Abfrage ab, ob diese Variable auf True ist. Wenn ja, dann wird die Punktzahl erhöht und die Variable wieder auf False gesetzt. So bekommt man nur einen Punkt, wenn auch ein Hindernis den linken Rand erreicht und daraufhin gelöscht wurde.

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

So eine Schleife benötigt man dann unterhalb des Erstellens der Hürden noch einmal. Dieses Mal jedoch nicht um die Hindernis-Elemente zu bewegen, sondern mit Hilfe einer If-Abfrage zu überprüfen, ob eines der Hürden-Elemente-Sprites das Sprite des Spielers berührt. 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 setzt man die Variable mit der Hürden-Geschwindigkeit ein. Um das Spiel stetig schwieriger zu machen kann man z.B. noch die erreichte Punktzahl um den Faktor fünf multiplizieren und von der Variable abziehen.

Viel Erfolg beim Meistern der heutigen Challenge!