intro Java Spiel K6 vasabii_Fotolia_70882828

Java Spiel Programmieren Tutorial – Teil 6: Die gegnerischen Panzer des Java Spiels programmieren


In der sechsten Lektion unseres Java Spiel Programmieren Tutorials werden wir die Klasse EnemyTank anlegen. Die EnemyTank-Klasse wird die gegnerischen Panzer unseres Java Spiels repräsentieren.

Die neue Klasse wird die Klasse Tank erweitern und dadurch die grundlegenden Eigenschaften von Spielobjekten und Panzern erben. Zusätzlich werden wir neue spezielle Eigenschaften und Fähigkeiten, wie das automatische Zielen und Schießen auf den Spielerpanzer, in ihr definieren.

Nachdem wir die neue Klasse erstellt haben, werden wir einige Änderungen an der GamePanel-Klasse vornehmen. Dies ist notwendig, um die Klasse EnemyTank testen und einen gegnerischen Panzer über die Spielfläche fahren lassen zu können.

Das Testen der neuen Klasse werden wir dann im letzten Kapitel dieser Lektion durchführen. Dazu werden wir unser Java Spiel in NetBeans ausführen und das Spielgeschehen in einem kleinen Video festhalten.

Nun wünschen wir euch viel Spaß beim sechsten Teil unseres Java Spiel Programmieren Tutorials. Los geht’s!

1. Erstellen der EnemyTank-Klasse, den gegnerischen Panzern unseres Java Spiels

Wir werden nun eine weitere Klasse unserem Java Projekt hinzufügen. Die neue Klasse wird den Namen EnemyTank tragen und den Bauplan für die gegnerischen Panzer in unserem Java Spiel bereitstellen.

Um die EnemyTank-Klasse zu erstellen, werden wir die folgenden beiden Arbeitsschritte ausführen:

  1. Anlegen der Klassendatei in NetBeans – Zuerst erstellen wir mit Hilfe der Entwicklungsumgebung NetBeans IDE die Klasse EnemyTank.
  2. Definieren der EnemyTank-Klasse – Im zweiten Schritt programmieren wir die neu erstellte Klasse aus. Die EnemyTank-Klasse ist nicht sehr groß, da sie die meisten Eigenschaften und Fähigkeiten von der Tank-Klasse erbt. In ihr werden wir eine neue Fähigkeit diesem speziellen Spielobjekt hinzufügen, das automatische Zielen und Schießen auf den Spielerpanzer.

Beginnen wir nun mit dem ersten Arbeitsschritt, dem Anlegen der EnemyTank.java Klassendatei.

1.1 Anlegen der Klassendatei EnemyTank.java in NetBeans

Die Klasse EnemyTank legen wir wie folgt an:

  1. Wir klicken mit der rechten Maustaste auf den Haupt-Packagenamen in der Projektleiste.
  2. Danach auf den New-Eintrag im Kontextmenü klicken.
  3. Anschließend auf den Eintrag Java Class... klicken.
java spiel k6 neue klasse anlegen

Eine neue Klasse unserem Java Projekt in NetBeans hinzufügen

Daraufhin öffnet sich der New Java Class-Dialog von NetBeans. In diesem Dialog geben wir als Namen der zu erstellenden Klasse EnemyTank ein.

Alle anderen Einstellungen lassen wir unverändert und bestätigen den Dialog mit einem Klick auf Finish.

java spiel k6 neue klasse enemytank

Der New Java Class Dialog von NetBeans

Jetzt generiert NetBeans eine neue Java-Datei mit dem Namen EnemyTank.java und fügt sie in das Hauptpaket unseres Java Projekts ein. Dies sollte bei euch wie folgt aussehen:

java spiel k6 neue klasse enemytank start

Die neu erstellte Java Klasse EnemyTank – Sie stellt den Bauplan für die gegnerischen Panzer im Spiel bereit

Die neue Klasse EnemyTank ist momentan noch leer. Das werden wir nun ändern und sie mit Quellcode füllen.

1.2 Definieren der EnemyTank-Klasse

Die Klassendatei EnemyTank.java haben wir nun mit Hilfe von NetBeans in unserem Java Projekt angelegt. Als Nächstes werden wir die EnemyTank-Klasse ausprogrammieren, also den Klassenbereich mit Variablen und Methoden füllen.

Dazu fügen wir den folgenden Quellcode in die EnemyTank-Klasse ein und ersetzen damit den generierten Code:


Die Klasse EnemyTank leiten wir in Zeile 5 von der Klasse Tank ab. Dadurch erbt die neue Klasse alle Eigenschaften und Fähigkeiten von der Klasse Tank und auch der Klasse GameObject, von der sich die Tank-Klasse wiederum ableitet.

Die beiden Membervariablen definieren wir in den Zeilen 7 und 8. Wir verwenden sie, um auf den Spielerpanzer zielen zu können. Aus der Variable playersTank lesen wir die Position des Spielerpanzers auf dem Spielfeld aus. Mit der Variable targetLocked halten wir fest, ob die Kanone auf den Spielerpanzer zeigt und somit das Ziel erfasst ist.

In den Zeilen 11 bis 25 definieren wir den Konstruktor der EnemyTank-Klasse, in dem wir hauptsächlich die Eigenschaften des zu erzeugenden gegnerischen Panzerobjekts vorgeben. Die Werte für Fahrgeschwindigkeit, Drehgeschwindigkeit und Nachladedauer vergeben wir zufällig mit Hilf der Methode Math.random(). Abschließend geben wir den accelerateTank(), wodurch der gegnerische Panzer in Bewegung gesetzt wird.

In den Zeilen 28 bis 40 definieren wir die Getter- und Setter-Methoden der beiden Klassenattribute. Anschließend überschreiben wir die makeMove() Methode mit den Zeilen 44 bis 52.

Die makeMove() jedes Spielobjekts wird pro Spielzyklus einmal von dem GamePanel-Objekt aufgerufen. In ihr führen wir den Spielzug des jeweiligen Spielobjekts aus. In diesem Fall stoppen wir den gegnerischen Panzer, sobald er seine Zielposition erreicht hat. Außerdem lassen wir ihn nach dem Spielerpanzer zielen. Mit dem Aufruf der makeMove() Methode der Superklasse Tank, delegieren wir das tatsächliche Bewegen des Panzers und seiner Kanone an die Implementierung der Vaterklasse.

Schließlich definieren wir die aimAtPlayer() Methode mit den Zeilen 54 bis 96. Diese Methode sieht auf den ersten Blick etwas komplex aus, ist aber relativ einfach, wenn man die zugrunde liegende Mathematik verstanden hat. Wie der Methodenname erwarten lässt, ist die Aufgabe dieser Methode den gegnerischen Panzer auf den Spielerpanzer zielen zu lassen.

Dazu wird zuerst die der Mittelpunkt des Spielerpanzers auf der Spielfläche bestimmt und danach die des gegnerischen Panzers. Durch Subtraktion dieser beiden Koordinatenpaare erhalten wir einen Vektor der in Richtung des Spielerpanzers, vom gegnerischen Panzer aus betrachtet, zeigt. Mit Hilfe der Arkustangensfunktion Math.atan2() von Java können wir aus den Komponenten des berechneten Richtungsvektors den entsprechenden Richtungswinkel berechnen.

Zieht man von diesem Richtungswinkel den Kanonenwinkel des gegnerischen Panzers ab, dann erhält man als resultierenden Winkel die Abweichung vom Ziel. Also wie viel Grad die Kanone des gegnerischen Panzer vom Ziel, dem Spielerpanzer, abweicht. Diesen Wert speichern wir in der Variabel deltaAngle.

Nimmt diese einen Wert kleiner gleich 0,01 an, gilt das Ziel als erfasst und wir setzen die Variable targetLocked auf true. Ist der Wert von deltaAngle größer als 0,01 oder kleiner als -0,01, lassen wir die Kanone in Richtung des Ziels drehen.

Dabei behandeln wir auch den Sonderfall, wenn der Spielerpanzer sich im Rücken des gegnerischen Panzers befindet. Sobald der Spielerpanzer genau hinter der gegnerischen Kanonenrichtung ist, lassen wir die Kanone in die Richtung der kürzeren Strecke drehen. Solange die Kanone den Spielerpanzer mit einer Drehbewegung verfolgt, ist die Variable targetLocked auf false gesetzt.

Weitere Informationen über die Arkustangensfunktion allgemein und die Math.atan2() Methode könnt ihr über folgende Links finden:

In NetBeans sollte die EnemyTank-Klasse nun wie folgt aussehen:

java spiel k6 neue klasse enemytank end

Die Klasse EnemyTank mit dem eingefügten Quellcode

In der oberen Abbildung haben wir einige Markierungen vorgenommen. Wir möchten damit auf einige wichtige Bestandteile der EnemyTank-Klasse hinweisen:

  • A: Die Membervariablen mit ihren Getter/Setter-Methoden – Die beiden Variablen playersTank und targetLocked verwenden wir in der Methode aimAtPlayer(), um den Spielerpanzer anzuvisieren.
  • B: Der Konstruktor der EnemyTank-Klasse – Mit dem Konstruktor erzeugen wir das EnemyTank-Objekt. Dabei nutzen wir auch den Konstruktor der Superklasse Tank mit Hilfe des Schlüsselworts super.
  • C: Die Methoden makeMove() und aimAtPlayer() – Wir überschreiben die Methode makeMove() und führen mit ihr den Spielzug des gegnerischen Panzers aus. Dabei rufen wir auch die makeMove() Methode der Superklasse Tank mit der Anweisung super.makeMove() auf. Mit der Methode aimAtPlayer() lassen wir den gegnerischen Panzer auf den Spielerpanzer zielen.

Mit dem Anlegen der EnemyTank-Klasse haben wir nun die Möglichkeit gegnerische Panzer in unserem Java Spiels anzulegen. Im nächsten Abschnitt werden wir ein Objekt vom Typ EnemyTank erzeugen und es gegen den Spielerpanzer kämpfen lassen.

2. Anpassen der GamePanel-Klasse und Erzeugen eines gegnerischen Panzers

Wir werden nun ein EnemyTank-Spielobjekt erzeugen und dieses über die virtuelle Spielfläche fahren lassen. Es wird den Spielerpanzer ins Visier nehmen und nach ihm feuern. Natürlich können wir den gegnerischen Panzer auch selbst bekämpfen.

Um das EnemyTank-Spielobjekt zu erzeugen, nehmen wir folgende Änderungen an der GamePanel-Klasse vor:

  1. Deklarieren des EnemyTank-Objekts als Membervariable der GamePanel-Klasse.
  2. Instanziieren des EnemyTank-Objekts in der createGameObjects() Methode.
  3. Ausführen des Spielzugs des gegnerischen Panzers durch Aufrufen seiner makeMove() Methode in der doOnTick() Methode.
  4. Zeichnen des EnemyTank-Objekts durch Aufrufen seiner paintMe() Methode in der paintComponent() Methode.

Wie zu sehen ist, werden wir den Quellcode der GamePanel-Klasse an vier Stellen erweitern. Es werden nur kleine Änderungen sein. Wichtig ist, dass diese an der korrekte Stelle der GamePanel-Klasse vorgenommen werden.

Wir öffnen nun die Klassendatei GamePanel.java im Editorfenster von NetBeans und fügen die gelb markierten Zeilen in den bereits vorhandenen Quellcode ein:


Die im oberen Quellcode vorgenommenen Änderung sind sehr einfach. Besonders aufpassen muss man bei den Änderungen in der Methode doOnTick(). In dieser Methode muss neben dem Einfügen von vier neuen Zeilen Quellcode auch eine bereits vorhandene Zeile auskommentiert werden.

Dabei handelt es sich um die Anweisung in Zeile 187, die nicht mehr benötigt wird und daher auskommentiert werden muss.

In NetBeans sollte der Quellcode der GamePanel.java Klassendatei nun wie folgt aussehen:

java spiel k6 klasse gamepanel

Die Klasse GamePanel mit dem zusätzlich eingefügten Quellcode

In der oberen Abbildung haben wir die in den Quellcode der GamePanel-Klasse neu eingefügten Anweisungen jeweils mit einem blauen Rahmen markiert:

  • A: Deklaration der Membervariable vom EnemyTank-Datentyp – Zu Testzwecken legen wir einen gegnerischen Panzer als Attribute der GamePanel-Klasse an.
  • B: Instanziieren des EnemyTank-Objekts – In der createGameObjects() Methode erzeugen wir das EnemyTank-Objekt und weisen es der Membervariablen zu.
  • C: Ausführen des Spielzugs des Spielobjekts durch Aufrufen der makeMove() Methode, Schießen und Prüfen auf Kollision – Mit dem Aufruf der makeMove() Methode lassen wir das Spielobjekt seinen Spielzug durchführen. Außerdem lassen wir den gegnerischen Panzer schießen und prüfen, ob er von einem Geschoss getroffen wurde. Ist dies der Fall, beenden wir das Java Spiel und lassen GAME OVER! anzeigen.
  • D: Zeichnen des Spielobjekts durch Aufrufen der paintMe() Methode – Damit der gegnerische Panzer auf der Spielfläche auch zu sehen ist, müssen dieser gezeichnet werden. Das Zeichnen lassen wir vom Spielobjekt selbst ausführen, durch Aufrufen der paintMe() Methode.

2.1 Die Klassendateien unseres Java Projekts zum Download

Somit haben wir alle Änderungen am Quellcode unseres Java Spiels für diese Lektion vorgenommen. Diesmal haben wir eine neue Klassen angelegt und an einer bestehenden Klasse Änderungen vorgenommen. Damit es nicht zu Missverständnissen kommt, haben wir unten alle Klassendateien zum Download bereitgestellt.

Ihr solltet noch einmal in Ruhe den kompletten Quellcode der aufgelisteten Klassendateien unseres Java Spiels anschauen und mit eurem vergleichen:

PanzerHQ.java
GameWindow.java
GamePanel.java
Coordinate.java
GameObject.java
Missile.java
Tank.java
EnemyTank.java

Als Nächstes werden wir unser Java Spiel starten und das erste Mal gegen einen gegnerischen Panzer antreten.

3. Testen unseres Java Spiels und des gegnerischen Panzers

Wir führen nun unser Java Projekt mit einem Klick auf das Run Project-Symbol aus.

java spiel entwickeln projekt starten

Starten unseres Java Projekts über den Run Projekt Button

Im Hintergrund wird jetzt unser Java Spiel von der NetBeans IDE erstellt und anschließend ausgeführt.

Diesmal begegnen wir unseren ersten Gegner. Der gegnerische Panzer fährt über die Spielfläche und zielt automatisch auf unseren Panzer. Wir können den Spielerpanzer mit den Pfeiltasten steuern. Den Panzerturm können wir mit den Tasten W und E nach links bzw. rechts drehen. Geschosse werden mit der Leertaste abgefeuert.

java spiel k6 enemytank

Das Spielfenster unseres Java Spiels jetzt mit einem gegnerischen Panzer der uns angreift

In der oberen Abbildung ist der Spielerpanzer am rechten Spielfeldrand zu sehen. Wir hatten gerade ein Geschoss abgefeuert und damit den Nachladevorgang gestartet. Dies erkennt man an dem schmalen grauen Balken über der Energieanzeige des Panzers.

Von der linken Seite nähert sich der gegnerische Panzer, der den Spielerpanzer bereits als Ziel erfasst hat und eifrig Geschosse in seine Richtung abfeuert.

3.1 Video – Funktionspräsentation unseres Java Spiels

In dem unteren Video ist das Spielfenster unseres selbst programmierten Java Spiels zu sehen. Wir sind in der Lage den Spielerpanzer selbst über die Spielfläche zu steuern. Auch die verbesserte Kollisionsabfrage ist jetzt implementiert, mit deren Hilfe wir Panzerabschüsse exakter erkennen können.

Neu hinzugekommen ist ein gegnerischer Panzer der von links nach rechts über das Spielfeld fährt. Der gegnerische Panzer zielt selbständig auf den Spielerpanzer und eröffnet das Feuer, sobald er ihn ins Visier genommen hat.

Die neuen Funktionen unseres Java Spiels haben wir im unteren Video vorgeführt:

Zu Beginn des Videos erklären wir noch einmal die Steuerung des Spielerpanzers. Dabei werden wir von einem generischen Spielerpanzer unter Beschuss genommen. Wir weichen einigen gegnerischen Geschossen aus, bis wir den final Schuss abgeben.

Als der gegnerische Panzer von unserem Geschoss getroffen wird, detektiert unser Java Spiel den Abschuss und endet unmittelbar danach. Zu Testzwecken geben wir dann GAME OVER! in dem Spielfenster aus.

Zusammenfassung

In der sechsten Lektion unseres Java Spiel Programmieren Tutorials haben wir die Klasse EnemyTank erstellt. Die EnemyTank-Klasse repräsentiert die gegnerischen Panzer in unserem Java Spiel.

Die neue Klasse haben wir von der Tank-Klasse abgeleitet und dadurch die grundlegenden Eigenschaften von Spielobjekten und Panzern geerbt. Zusätzlich haben wir neue spezielle Eigenschaften und Fähigkeiten, wie das automatische Zielen und Schießen auf den Spielerpanzer, in ihr der EnemyTank-Klasse realisiert.

Um gegnerische Panzer auf der Spielfläche zu erzeugen, haben wir einige Änderungen an der GamePanel-Klasse vorgenommen. Wir haben zu Testzwecken einen gegnerischen Panzer von links nach rechts über das Spielfeld fahren lassen.

Dabei hat der gegnerische Panzer den Spielerpanzer selbständig ins Visier genommen und nach ihm geschossen. Das Spielgeschehen haben wir zur besseren Veranschaulichung in einem kleinen Video festgehalten.

In der nächsten Lektion unseres Java Spiel Programmieren Tutorials werden wir die Spiellogik des Panzer-Shooters implementieren. Dazu werden wir die GamePanel-Klasse aufräumen und von ihrem Testcode befreien.


Comments 3

  1. Tobias

    Vielen Dank für das Tutorial!
    Habe jetzt beide Android sowie das Java Tutorial durchgearbeitet und muss echt sagen – klasse Arbeit! Alles ist stets ausführlich erklärt, auch wenn man als Anfänger nicht alles immer versteht :D

    Freue mich auf die nächste Lektion des Panzer Tutorials und auf weitere Android Fortsetzungen / Tutorials? :)

    Gerade als Anfänger ist es immer schwer etwas zu programmieren, da man ständig kleine Fehler macht und teilweise Stunden braucht, bis man den Fehler gefunden hat – oder gänzlich verzweifelt. Deshalb habe ich mit großer Freude deine Tutorials durchgemacht.
    Großes Lob, mach weiter so!

    1. Post
      Author
      Chris

      Hallo Tobias,

      danke für Dein Lob! Es ist immer eine große Hilfe für uns Feedback über die Tutorials zu erhalten. Dadurch erfahren wir, ob die Inhalte für die Leser verständlich sind oder ob Probleme auftreten. Danke nochmals für dein Feedback!

      Viele Grüße, Chris

  2. Pingback: Java Spiel Programmieren Tutorial - Das Java Projekt anlegen

Hinterlasse eine Antwort

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert *