Inf9 3.4 Datentyp boolean und zweiseitige bedingte Anweisung

Zu den Aufgaben

Nachdem nun die Formen auf dem Bildschirm sich alleine bewegen können, brauchen wir für ein Spiel nun noch die Interaktion mit den Tastatureingaben.

Wir wollen nun einen Kreis programmieren, der – je nachdem welche Taste gedrückt wird – sich in die passende Richtung bewegt. Für die Überprüfung bietet Processing die Methoden keyPressed(), die immer dann aufgerufen wird, wenn eine Taste heruntergedrückt wird, und keyReleased(), die immer dann aufgerufen wird, wenn eine Taste losgelassen wird.

Processing speichert im globalen Attribut key, welche Taste es genau war. Da es mehrere Tasten (WASD) gibt, mit denen wir unseren Kreis bewegen wollen, müssen wir die aktuell gedrückten Tasten speichern. Zum Speichern, ob eine Taste gerade gedrückt wird, bietet sich ein Datentyp an, der nur Ja oder Nein speichert.

Der Datentyp boolean speichert nur die Zustände WAHR (true) oder FALSCH (false) ab. Er ist ideal geeignet um Bedingungen oder das Ergebnis einer Abfrage abzuspeichern.

Merksatz 2.2.1

Wir definieren das Attribut wie immer am Anfang:

boolean wTaste;

In der setup() Methode setzen wir den Startwert, dass die Taste nicht gedrückt ist:

void setup()
{
   wTaste = false;
}

Nun sind alle Vorbereitungen abgeschlossen, um die Methoden keyPressed() und keyReleased() zu definieren. Wenn ein key gedrückt wird, soll der Wert des Attributs auf true gesetzt werden und immer wenn die keyReleased() Methode aufgerufen wird, soll andersherum der Wert auf false gesetzt werden.

void keyPressed()
{
   if(key=='w')
   {
      wTaste = true;
   }
}
void keyReleased() 
{
   if(key=='w')
   {    
      wTaste = false;
   }
}

Der Vergleich zwischen zwei Werten geschieht mit einem doppelten Gleichheitszeichen ==, da das einfache Gleichheitszeichen = eine Zuweisung ausdrückt.

Merksatz 2.2.2

Zum Abschluss muss in der draw() Methode noch, je nachdem welche Tasten gedrückt sind, der Kreis bewegt werden:

void draw()
{
   if(wTaste)
   {
      yKreis = yKreis - 1;
   }
}

Die zweiseitige Bedingte Anweisung

Nun haben wir einen Kreis, den wir mit Tastatureingaben bewegen können. Für ein Spiel brauchen wir oft auch noch eine Kollision mit anderen Objekten. Wir werden in unserem Spiel ein Rechteck einsammeln müssen.

Um die Kollision zwischen einem Rechteck und einem Kreis zu modellieren, müssen wir die Lage des Kreises zum Rechteck bestimmen. Dafür benutzen wir mehrere Zonen:

Der Kreis kann an verschiedenen Stellen im Vergleich zum Rechteck sein. Je nachdem, wo der Kreis im Vergleich zum Rechteck sich befindet, muss ein anderer Punkt auf dem Rand des Rechtecks zum Vergleich herangezogen werden.

Die Koordinaten des Kollisionspunktes kann man wie folgt erkennen:

Bestimmung des Kollisionspunktes: x-Koordinate

In Code übersetzt muss der FALSCH Teil der bedingten Anweisung mit dem Codewort else (engl. sonst) beschrieben werden. Wie man im Struktogramm sieht, können mehrere bedingte Anweisungen verschachtelt werden:

if(xKreis < xRechteck)
{
   xKollision = xRechteck;
}
else
{
   if(xKreis > xRechteck + Breite)
   {
      xKollision = xRechteck + Breite;
   }
   else
   {
      xKollision = xKreis;
   }
}

Die y-Koordinate lässt sich analog überprüfen.

Kollision mit dem Satz des Pythagoras

Um nun mit den Koordinaten P(xKreis|yKreis) und Q(xKollision|yKollision) auszurechnen, ob der Abstand zwischen beiden Punkten kleiner als der Kreis ist, nutzen wir den Satz des Pythagoras und den Code

if(sqrt((xKollision-xKreis)*(xKollision-xKreis) + 
          (yKollision-yKreis)*(yKollision-yKreis))<Radius)
{
   //Kollision!!!
}

Aufgabe 1:

Bei den Aufgaben verwenden wir die Entwicklungsumgebung Processing. Wenn du einen Befehl suchst, schaue auf https://processing.org/reference nach!

  • Deklariere alle nötigen Attribute, um einen Kreis mit der Tastatur auf dem Bildschirm bewegen zu können.
  • Implementiere die setup() und draw() Methoden. Dabei soll die Größe des Fensters auf Breite 500 und Höhe 400 gesetzt werden und der Kreis bei Position (100|200) gezeichnet werden. Der Radius des Kreises ist anfangs 40.

Aufgabe 2:

  • Ergänze das Attribut boolean wTaste und ermögliche, dass man den Kreis durch drücken der Taste 'w' auf der Tastatur mithilfe der Methoden keyPressed() und keyReleased() nach oben bewegt.
  • Ergänze die Tasten 'a', 's' und 'd' und lasse so den Kreis auf der Spielfläche bewegen.

Aufgabe 3:

  • Wir wollen nun die Kollision des Rechtecks mit dem Kreis umsetzen. deklariere dafür Attribute xKollision, yKollision und alle nötigen Attribute, um ein Rechteck auf dem Bildschirm anzuzeigen. Das Rechteck sollte die Breite und Höhe 10 haben.
  • Sorge dafür, dass mithilfe von bedingten Anweisungen, die jeweilige Kollisionsecke bestimmt wird.
  • Lasse bei einer Kollision den Kreis die Farbe (0,200,0) annehmen. Sonst sollte der Kreis die Farbe (0,0,240) annehmen.

Aufgabe 4:

  • Schaue nach, wie man in Processing eine Zufallszahl generiert und lasse das Rechteck eine zufällige Spielposition einnehmen, wenn es vom Kreis getroffen wird.
  • Lasse den Radius des Kreises bei jedem Einsammeln um 1 wachsen.
  • Erstelle weitere Rechtecke, die sich bewegen und eine zufällige Größe zwischen 20 und 50 haben. Immer wenn der Kreis ein kleineres Rechteck berührt, soll er wachsen, aber wenn er einen größeren trifft, schrumpft er wieder.

Aufgabe 5: (Advanced Stuff)

  • Baue eine Score ein, die zählt, wie groß du bist.
  • Lasse die Rechtecke andere Farben annehmen, je nachdem wie groß sie sind.
  • Baue einen Soundeffekte ein, wenn ein Rechteck gefressen wird.
  • Wie wäre es mit einem Zweispielermodus: WASD vs. IJKL, wer die meisten Rechtecke in einer gewissen Zeit frisst, gewinnt.

Zurück zur Übersicht