Spielsteuerung

Gliederung des Spielfeldes

Im Folgenden werden wir den Ablauf des Spiels programmieren und zunächst noch drei grafische Randbegrenzungen hinzufügen.
Zunächst teilen wir mit Hilfe der Klasse Rectangle den Bildschirm durch drei Rechtecke, die nur fünf Pixel hoch sind, sich aber über die gesamte Breite des Fensters erstrecken. Der Konstruktor der Klasse erwartet als Parameter die x- und y-Koordinate der linken oberen Ecke sowie die Breite und die Höhe des Rechtecks.

Mit new Rectangle(0, 0, 800, 5); erhalten wir z. B. eine Begrenzungslinie im oberen Bereich des Grafikfensters Die Anweisung erzeugt lediglich das Objekt, ohne dass wir es in einer Variablen vom Typ Rectangle speichern. Das ist nicht nötig, da wir keine weiteren Methoden des Objekts mehr aufrufen werden.

Ergänze in der Datei Spiel den Code, so dass alle drei Linien im Grafikfenster erscheinen.
Hinweis: Das Zeichenfenster ist 600 Pixel hoch. Achte darauf, das Rechteck der unteren Begrenzung nicht außerhalb des sichtbaren Bereichs zu erzeugen.

// Begrenzungslinie am oberen Bildschirmrand 
new Rectangle(0, 0, 800, 5);
// Trennlinie in der Bildschirmmitte 
new Rectangle(0, 300, 800, 5);
// Begrenzungslinie am unteren Bildschirmrand 
new Rectangle(0, 595, 800, 5); // x=595, damit das 5 Pixel hohe Rechteck noch sichtbar ist

Die Rechtecke gliedern nicht nur optisch das Spielfeld. Wenn das Raumschiff gegen eine Trennlinie berührt, wird dies als Schaden gezählt. Da das Rechteck im Gegensatz zu den Weltraumschrott-Objekten nicht verschwindet, berührt das Raumschiff beim nächsten Aufruf der act()-Methode immer noch das Rechteck. Somit wird der Schaden sehr schnell auf den Maximalwert von 5 hochgezählt und das Spiel endet.

Erzeugen von Hindernissen

Wir müssen jetzt nur noch dafür sorgen, das am rechten Spielfeldrand immer wieder neue Weltraumschrott-Objekte erzeugt werden. Dabei soll ihre Farbe und ihre vertikale Position zufällig sein.
Zur Erzeugung von zufälligen Zahlen verwenden wir die Klasse Zufall, die eine Methoden zum Erzeugen von ganzzahligen Zufallszahlen in einem bestimmten Bereich bereitstellt.

// Hilfsklasse für Zufallszahlen
class Zufall {
   public static int gibInteger(int min, int max) {
      return Math.floor(Math.random() * (max + 1 - min) + min);
   }
}

Der Aufruf erfolgt durch: Zufall.gibInteger(int min, int max).

Das nächste Programmfenster enthält den bisherigen Code sowie in der Datei Spiel die Klasse Zufall mit einem Beispiel zur Erzeugung von Zufallszahlen.

Analysiere das Programm in der Datei Spiel und starte es.

Der Konstruktor für unseren Weltraumschrott hat folgende Parameter:
Weltraumschrott(double x, double y, double radius, int color)
Beim Erzeugen von neuen Objekten wählen für den Radius den Wert 10. Die übrigen Werte sollen zufällig gesetzt werden:
Für die x-Position der Objekt empfielt sich ein Wert zwischen 850 und 900. Das heißt, dass sich neue Objekte zunächste außerhalb des sichtbaren Bereichs (das Fenster ist nur 800 Pixel breit) befinden und außerdem nicht immer den gleichen vertikalen Abstand besitzen. Zeitlich hintereinander erzeugte Objekt können somit grafisch auch einmal übereinander liegen.
Für das Raumschiff in der oberen Spielfeldhälfte sollen sich die Mittelpunkte kreisförmigen Objekte im Bereich von y=20 bis y=280 befinden. Bei größeren bzw. kleineren Werte würden die Kreise gleich mit den Begrenzungslinien kollidieren und verschwinden, was aber im Grunde das Spiel kaum beeinflussen würde.

Die Farbe der erzeugten Kreise wird mit einer Zahl zwischenn 0 und 16.581.375 festgelegt. Für diese aus den Farben rot, grün und blau gemischte Farbe gilt:
255*255*rot+255*grün+blau, wobei rot, grün und blau den jeweiligen Farbanteil der Mischfarbe mit einer Zahl zwischen 0 und 255 beschreibt.
Wir werden uns aber darüber keine weiteren Gedanken machen, sondern für die Farbe eine zufällige Zahl zwischen 0 und 16.581.375 wählen. Dabei ist nur zu bedenken, dass auch sehr dunkle Farben möglich sind und einzelne Hindernisse kaum oder nur sehr schwer zu erkennen sein werden.

Das Erzeugen des Weltraumschrotts soll in einer Endlosschleife erfolgen, die man am einfachsten umsetzt durch:

   while(true) {
      // Anweisungen
   }

Ergänze den folgenden Programmcode in der Datei Spiel, so dass in der oberen Spielfeldhälfte Hindernisse an zufälliger Position und mit zufälliger Farbe entstehen.
Teste dein Programm.

   // Variable x deklarieren und eine zufällige Zahl zwischen 850 und 900 zuweisen
   int x = Zufall.gibInteger(850, 900);
   // Variable y deklarieren und eine zufällige Zahl zwischen 20 und 280 zuweisen
   int y = Zufall.gibInteger(20, 280);
   // Variable farbe deklarieren und eine zufällige Zahl zwichen 0 und 16581375 zuweisen
   int farbe = Zufall.gibInteger(0, 16581375);
   // ein neues Objekt der Klasse Weltraumschrott mit Radius 10 und den zufälligen Werten erzeugen
   new Weltraumschrott(x, y, 10, farbe);

Erhöhung des Schwierigkeitsgrades im Spielverlauf

Die Anzahl der Hindernisse, die pro Sekunde erzeugt werden, hängt davon ab, wie viele Schritte pro Sekunde beim Programmablauf mit Hilfe des Schiebereglers eingestellt sind.

Die Anzahl der Programmschritte kann aber auch über die Anweisung SystemTools.setSpeed(int wert) festgelegt werden. Wir nutzen dies, indem wir eine Variable systemgeschwindigkeit deklarieren und diese zu Beginn auf 200 setzen.

Bei jeder Wiederholung innerhalb der while-Schleife wird der Wert der Variable um eins erhöht und die Systemgeschwindigkeit auf diesen Variablenwert gesetzt.

Ergänze den Programmcode der Datei Spiel in den Zeilen 11, 19 und 21 entsprechend und teste den Spielverlauf

// Variable systemgeschwindigkeit als Ganzzahl deklarieren und mit 200 initialisieren
int systemgeschwindigkeit = 200;
// Endlosschleife zum Erzeugen des Weltraummülls
while(true) {
   int x = Zufall.gibInteger(850, 900);
   int y = Zufall.gibInteger(20, 280);
   int farbe = Zufall.gibInteger(0, 16581375);
   new Weltraumschrott(x, y, 10, farbe);
   // Ablaufgeschwindigeit mit SystemTools.setSpeed() setzen
   SystemTools.setSpeed(systemgeschwindigkeit);
   // systemgeschwindigkeit um 1 erhöhen
   systemgeschwindigkeit++;
}

Damit ist die Programmierung des Spiels für einen Spieler abgeschlossen.