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.
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);
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.