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:
angriff1angriff2verteidigung1verteidigung2
Nach jedem Aufruf soll das Spiel auch wieder kurz warten().
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().
Ergänzt den Aufruf von verteidigerAmZug() in der Methode tasteReagieren.
@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.