Lernpfad:Hehomon/12
Die Hehomons sind nun in der Arena angetreten. Der Kampf kann beginnen!
Als erstes ist das angreifende Hehomon an der Reihe und darf eine seine Fähigkeiten einsetzen. Der Angreifer wird vom Spieler gesteuert, also müssen wir hier auf die Benutzereingaben reagieren. Dazu legen wir folgende Tastatursteuerung fest:
A
- Angriff 1S
- Angriff 2D
- Verteidigung 1F
- Verteidigung 2
Angreifer: Auf Tasten reagieren
Die Engine-Alpha macht es und einfach, auf Tastendruck zu reagieren. In Schritt 9 habt ihr die Klasse Spiel
erstellt und musstet eine Methode überschreiben, damit keine Fehler entstehen. Die Methode hatte die Signatur void tasteReagieren( int pTastencode )
, was sich für unsere Zwecke doch ganz hilfreich anhört.
Tatsächlich wird die Methode von der Engine-Alpha jedes Mal aufgerufen, wenn der Spieler eine Taste auf der Tastatur betätigt. Der Parameter pTastencode
ist eine Zahl, die für jede Taste anders ist. Der Buchstabe A
hat zum Beispiel die Nummer 0
, S
die Nummer 18
, D
die 3
und F
die 5
.
Damit man sich die Zahlen besser merken kann, definiert Engine-Alpha in der Klasse Taste
eine Reihe von Konstanten (also Variablen, die sich nicht verändern), die einfacher zu benutzen sind. Statt 5
schreibt ihr dann Taste.F
, und so weiter.
Möchtet ihr nun also eine Aktion (in diesem Fall den Angriff 1) auslösen, wenn der Spieler die Taste A
drückt, passt ihr die Methode tasteReagieren
so an:
pulic void tasteReagieren( int pTastencode ) {
if( pTastencode == Taste.A ) {
// Aktion bei Taste A
angreifer.angriff1(verteidiger);
warten(1000);
}
}
Mit else if( ... )
könnt ihr dann die verschiedenen Tasten abarbeiten und die passende Aktion auslösen.
Die Funktion warten( int pMillisekunden )
pausiert die Ausführung des Spiels für die angegebene Anzahl Millisekunden. Der nächste Befehl wird erst nach dieser Zeit ausgeführt.
Implementiert die Methode tasteReagieren
für die vier Fähigkeiten wie oben beschrieben.
Erstellt dann ein neues Spiel
-Objekt und probiert die Tasten aus. Die Veränderung der Eigenschaften könnt ihr im Inspektor betrachten.
@Override
public void tasteReagieren(int tastencode) {
if( tastencode == Taste.A ) {
angreifer.angriff1(verteidiger);
warten(500);
} else if( tastencode == Taste.S && w ) {
angreifer.angriff2(verteidiger);
warten(500);
} else if( tastencode == Taste.D && w ) {
angreifer.verteidigung1(verteidiger);
warten(500);
} else if( tastencode == Taste.F && w ) {
angreifer.verteidigung2(verteidiger);
warten(500);
}
}
Verteidiger: Eine einfache K.I.
Das verteidigende Hehomon wird nicht vom Spieler gesteuert, sondern vom Computer. Der Gegner verfügt also über eine künstliche Intelligenz, kurz "K.I". Die K.I. unseres Spiels ist zunächst nicht besonders ausgefeilt: Der Gegner wählt eine seiner vier Fähigkeiten zufällig aus und wendet sie an.
Implementiert in Spiel
eine neue Methode public void verteidigerAmZug()
, die eine Zufallszahl zwischen 1 und 4 generiert und dann die zugehörige Methode von verteidiger
aufruft:
angriff1
angriff2
verteidigung1
verteidigung2
Nach jedem Aufruf soll das Spiel auch wieder kurz warte
n.
Ihr könnt einen Großteil des Quelltextes der Methode tasteReagieren
kopieren und als Grundlage nutzen.
Die Klasse Game
der Engine-Alpha hat eine Methode int zufallsZahl(int pObereGrenze)
, die ihr benutzen könnt, um einfach eine Zufallszahl zu generieren. Es werden Zahlen von 0 bis pObereGrenze
erzeugt. Also kann eine Zahl zwischen 1 und 4 mit zufallsZahl(3)+1
erzeugt werden.
private void verteidigerAmZug() {
int zufall = zufallsZahl(3)+1;
if( zufall == 1 ) {
verteidiger.angriff1(angreifer);
warten(500);
} else if( zufall == 2 ) {
verteidiger.angriff2(angreifer);
warten(500);
} else if( zufall == 3 ) {
verteidiger.verteidigung1(angreifer);
warten(500);
} else if( zufall == 4 ) {
verteidiger.verteidigung2(angreifer);
warten(500);
}
}
Nach jeder Aktion des Spielers führt die K.I. ihren Zug aus. Daher rufen wir verteidigerAmZug()
jedes Mal auf, wenn die Aktion des angreifenden Hehomons zuende ist (nach dem Aufruf von warten()
.
@Override
public void tasteReagieren(int tastencode) {
if( tastencode == Taste.A ) {
angreifer.angriff1(verteidiger);
warten(500);
verteidigerAmZug();
} else if( tastencode == Taste.S && w ) {
angreifer.angriff2(verteidiger);
warten(500);
verteidigerAmZug();
} else if( tastencode == Taste.D && w ) {
angreifer.verteidigung1(verteidiger);
warten(500);
verteidigerAmZug();
} else if( tastencode == Taste.F && w ) {
angreifer.verteidigung2(verteidiger);
warten(500);
verteidigerAmZug();
}
}
Vertiefende Informationen: Die switch-Anweisung
Wenn ihr mehrere if-elseif-elseif-...
Anweisungen hintereinander programmiert, und die Bedingung von einer Zahl abhängt, dann könnt ihr auch eine switch
Anweisung benutzen. Die Syntax sieht für das Hehomon-Beispiel so aus:
switch( pTastencode ) {
case Taste.A:
angreifer.angriff1(verteidiger);
warte(1000);
break;
case Taste.S:
angreifer.angriff2(verteidiger);
warte(1000);
break;
case Taste.D:
angreifer.verteidigung1(verteidiger);
warte(1000);
break;
case Taste.F:
angreifer.verteidigung2(verteidiger);
warte(1000);
break;
}
Außerdem kann man zusätzlich einen else
-Fall einbauen (den wir im Hehomon-Beispiel nicht brauchen):
switch( pTastencode ) {
// Hier stehen die "cases"
default:
// Dieser Code wird ausgeführt, wenn
// keiner der "cases" ausgeführt wurde.
break;
}
Die switch
-Anweisung kann nur mit primitiven Datentypen (int
, char
, ...) verwendet werden, also nicht mit String
oder anderen Objekten.