In dieser Lektion werden wir unserer Spielfigur die Möglichkeit geben, Kugeln abzufeuern. Treffen können diese leider noch nichts, aber damit legen wir einen Grundstein für die nächsten Lektionen, wo wir unter anderem die Kollision zweier Objekte behandeln werden. Wie werden wir heute vorgehen? 1. Wir werden eine Projectiles (Kugel) Klasse erstellen, welche wir als Bauplan für all unsere Kugeln nehmen werden. 2. Innerhalb der Roboter Klasse werden wir eine Methode erstellen, welche das Schießen handhabt. 3. In der StartingClass werden wir unsere Kugeln zeichnen lassen und uns die Möglichkeit geben, sie mit der Strg-/Ctrl-Taste (Steuerung bzw. Control) abzufeuern.
Stunde #2-20: Erstellen der Kugeln Klasse
Wir erstellen hier nun den Entwurf unserer Kugel. Dabei gehen wir genauso vor wie in allen anderen Klassen: 1. Erstellen der Projectile Klasse 2. Variablen definieren 3. Erstellen einer update()-Methode 4. Hilfsmethode erstellen
I. Erstellen der Projectile Klasse
1. Rechtsklick auf Basteldroid Paket, danach New > Class auswählen.
2. Name Projectile
3. Die Box mit Constructors from superclass: auswählen.
4. Mit Finish bestätigen.
|
1 2 3 4 5 6 7 8 9 |
package basteldroid; public class Projectile { public Projectile() { // TODO Auto-generated constructor stub } } |
II. Variablen erstellen
Lasst uns kurz darüber nachdenken, welche Variablen wir benötigen? Unser Projektil bzw. die Kugel hat eine Geschwindigkeit, X- und Y-Koordinaten und sehen wollen wir sie auch, also werden wir Folgendes hinzufügen:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package basteldroid; public class Projectile { <span style="color: #ff0000"> private int x, y, speedX; private boolean visible;</span> public Projectile() { // TODO Auto-generated constructor stub } } |
Nun müssen wir noch einige Änderungen an unserem Konstrukteur vornehmen. Momentan nimmt dieser keine Parameter. Wir wollen, dass er immer die obere linke Ecke unserer Kugel nimmt, also startX und startY. Innerhalb des Konstrukteurs werden die Variablen startX und startY in x und y geändert, die Geschwindigkeit der Kugel bekommt einen Wert zugewiesen und es wird eingestellt, dass die Kugel sichtbar ist.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package basteldroid; public class Projectile { private int x, y, speedX; private boolean visible; public Projectile(<span style="color: #ff0000">int startX, int startY</span>) { // TODO Auto-generated constructor stub <span style="color: #ff0000">x = startX; y = startY; speedX = 7; visible = true;</span> } } |
III. Erstellen der update()-Methode
Diese Methode wird wie in allen anderen Klassen immer aktualisiert. Daher ändern wir hier die Position der Kugeln im Verhältnis zu der Geschwindigkeit und stellen ein, wie sie reagiert, wenn sie mit einem Objekt kollidiert. Die Kollision werden wir aber erst in einer späteren Lektion lernen. Nun werden wir die update()-Methode erstellen und die benötigten Variablen einfügen.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
package basteldroid; public class Projectile { private int x, y, speedX; private boolean visible; public Projectile(int startX, int startY) { // TODO Auto-generated constructor stub x = startX; y = startY; speedX = 7; visible = true; } <span style="color: #ff0000"> public void update(){ x += speedX; if (x > 800) { visible = false; } }</span> } |
Die Anweisung x += speedX; wird nun kontinuierlich die X-Koordinate aktualisieren, indem die Geschwindigkeit in x-Richtung hinzu addiert wird. Sobald die Kugel außerhalb des Bildschirms ist, soll sie entfernt werden, so belegt diese nicht unnötig Speicher.
IV. Getters and Setters
1. Rechtsklick am Ende unseres Codes, dann Source > Generate Getters and Setters… 2. Select all 3. OK Damit haben wir unsere Projectile Klasse fertig gestellt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 |
package basteldroid; public class Projectile { private int x, y, speedX; private boolean visible; public Projectile(int startX, int startY) { // TODO Auto-generated constructor stub x = startX; y = startY; speedX = 7; visible = true; } public void update(){ x += speedX; if (x > 800) { visible = false; } } public int getX() { return x; } public int getY() { return y; } public int getSpeedX() { return speedX; } public boolean isVisible() { return visible; } public void setX(int x) { this.x = x; } public void setY(int y) { this.y = y; } public void setSpeedX(int speedX) { this.speedX = speedX; } public void setVisible(boolean visible) { this.visible = visible; } } |
Stunde #2-21: Erstellen einer ArrayList in der Roboter Klasse
Es wäre wirklich sehr aufwendig, jede einzelne Kugel zu programmieren, die unser Roboter abschießen kann, wenn wir auf Schießen drücken. Daher werden wir eine Liste in unser Spiel implementieren namens ArrayList. Diese erlaubt uns, unser Projectile Objekt in einem Container von zunehmender Größe zu speichern. 1. Als Erstes werden wir unsere neue Variable in Robot.java erstellen und ArrayList importieren.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
package basteldroid; <span style="color: #ff0000">import java.util.ArrayList;</span> public class Robot { //Variablen, welche nur in einer Klasse benötigt werden, sollten private sein. //So können nur die dazugehörigen Methoden diese ändern. final int JUMPSPEED = -15; final int MOVESPEED = 5; final int GROUND = 382; private int centerX = 100; private int centerY = GROUND; private boolean jumped = false; private boolean movingLeft = false; private boolean movingRight = false; private boolean ducked = false; <span style="color: #ff0000">private ArrayList projectiles = new ArrayList();</span> private static Background bg1 = StartingClass.getBg1(); private static Background bg2 = StartingClass.getBg2(); private int speedX = 0; private int speedY = 1; |
2. Unterhalb der jump()-Methode werden wir eine weitere neue Methode hinzufügen: shoot().
|
1 2 3 4 |
public void shoot() { Projectile p = new Projectile(centerX + 50, centerY - 25); projectiles.add(p); } |
Diese Methode erstellt eine neue Kugel und gibt ihr den Namen p. Gleichzeitig fügt sie diese zu der Projectile ArrayList hinzu. Die Kugel wird 50 Pixel neben der Mitte und 25 Pixel über der Mitte des Roboters erstellt, also genau da, wo unsere Pistole ist. 3. Nun erstellen wir noch eine Getter Methode, welche wir einfach am Ende des Codes hinzufügen.
|
1 2 3 |
public ArrayList getProjectiles() { return projectiles; } |
Damit können wir aus anderen Klassen auf die ArryList zugreifen.
Stunde #2-22: Zeichnen der Kugel in der StartingClass
I. Änderung der run()-Methode
Als Erstes importieren wir die ArrayList auch in der StartingClass und ergänzen dann die run()-Methode durch Folgendes:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
@Override public void run() { // TODO Auto-generated method stub while (true) { bg1.update(); bg2.update(); robot.update(); hb.update(); hb2.update(); if (robot.isJumped()){ currentSprite = characterJumped; }else if (robot.isJumped() == false && robot.isDucked() == false){ currentSprite = character; } <span style="color: #ff0000"> ArrayList projectiles = robot.getProjectiles(); for (int i = 0; i < projectiles.size(); i++) { Projectile p = (Projectile) projectiles.get(i); if (p.isVisible() == true) { p.update(); } else { projectiles.remove(i); } }</span> repaint(); try { Thread.sleep(17); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } |
Was haben wir hier nun geschrieben? Wir haben eine neue ArrayList mit dem Namen projectiles erstellt und ihr den Wert aus der Projectiles ArrayList aus der Robot Klasse zugewiesen. Als Nächstes haben wir eine Schleife erstellt, welche so lange läuft, wie i kleiner ist als die Größe der projectlies ArrayList, dies ist die Zahl der Kugeln, die darin gespeichert sind. Als Nächstes überprüfen wir, welche Kugel wir abfeuern, die 1., 2., 3. oder 4. aus unserer ArrayList, also die Kugel mit dem Index i.
Zur Veranschaulichung hier noch ein anderes Beispiel: Angenommen, wir haben ein Array Liste = [1, 2, 3, 5, 7], dann haben die einzelnen Elemente die Indizes 0, 1, 2, 3, und 4. Also durchläuft unsere Schleife die komplette ArrayList und setzt unser Objekt mit p (aus der Robot Klasse) gleich.
Nachdem dies passiert ist, wird überprüft, ob die Kugel noch sichtbar ist. Ist dies nicht der Fall, wird p entfernt, indem einfach i aus der projectiles ArrayList entfernt wird. Um es zusammenzufassen, wir haben hier eine Schleife geschrieben mit einem Index i in der projectiles ArrayList, welcher sich immer um 1 erhöht. Diesen Index haben wir mit p gleichgesetzt und überprüfen dadurch, ob die Kugel noch innerhalb des Bildschirms ist (dann fliegt die Kugel weiter) oder bereits außerhalb (dann wird die Kugel wird gelöscht).
II. Änderung der paint()-Methode
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
@Override public void paint(Graphics g) { // TODO Auto-generated method stub g.drawImage(background, bg1.getBgX(), bg1.getBgY(), this); g.drawImage(background, bg2.getBgX(), bg2.getBgY(), this); <span style="color: #ff0000">ArrayList projectiles = robot.getProjectiles(); for (int i = 0; i < projectiles.size(); i++) { Projectile p = (Projectile) projectiles.get(i); g.setColor(Color.YELLOW); g.fillRect(p.getX(), p.getY(), 10, 5); }</span> g.drawImage(currentSprite, robot.getCenterX() - 61, robot.getCenterY() - 63, this); g.drawImage(heliboy, hb.getCenterX() - 48, hb.getCenterY() - 48, this); g.drawImage(heliboy, hb2.getCenterX() - 48, hb2.getCenterY() - 48, this); } |
Auch hier haben wir eine neue ArrayList erstellt, die Liste aus der update()-Methode ist auch nur in dieser benutzbar, also müssen wir in einer neuen Methode eine neue Liste erstellen. Des Weiteren haben wir eine gelbe Kugel gezeichnet, welche 10 Pixel breit und 5 Pixel hoch ist.
Stunde #2-23: Schießen
Das Einzige, was uns noch fehlt, ist eine Taste, mit der wir unsere neu erstellte Kugel auch abfeuern können. Wir nehmen die STRG- bzw. CTRL-Taste . Dazu müssen wir unsere keyPressed()-Methode ändern.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
@Override public void keyPressed(KeyEvent e) { // TODO Auto-generated method stub switch (e.getKeyCode()) { case KeyEvent.VK_UP: System.out.println("Bewege dich hoch"); break; case KeyEvent.VK_DOWN: currentSprite = characterDown; if (robot.isJumped() == false){ robot.setDucked(true); robot.setSpeedX(0); } break; case KeyEvent.VK_LEFT: robot.moveLeft(); robot.setMovingLeft(true); break; case KeyEvent.VK_RIGHT: robot.moveRight(); robot.setMovingRight(true); break; case KeyEvent.VK_SPACE: robot.jump(); break; <span style="color: #ff0000">case KeyEvent.VK_CONTROL: if (robot.isDucked() == false && robot.isJumped() == false) { robot.shoot(); } break;</span> } } |
Für den Fall, dass die CONTROL-Taste gedrückt wird, haben wir hier eingestellt, dass die shoot()-Methode aufgerufen wird. Gleichzeitig überprüfen wir, ob unser Roboter sich duckt oder gerade springt oder beides. Nun können wir das Spiel starten und unsere Kugeln abfeuern. Damit sind wir auch schon am Ende dieser Lektion. Mittlerweile wiederholen sich die meisten Dinge immer und immer wieder, also werde ich versuchen, diese Erklärungen einzukürzen. In der nächsten Lektion werden wir uns mit Animationen beschäftigen.
Source Code
Für diejenigen unter euch, die hier einsteigen möchten, ohne den ganzen Code abtippen zu müssen, habe ich das Projekt exportiert. Mit der Importfunktion könnt ihr das Projekt bequem bei euch einfügen. Unter der Kategorie Eclipse und Java > Import und Export habe ich erklärt, was dafür zu tun ist.
Falls ihr Fragen habt, immer raus damit, ich helfe euch sehr gerne. Hinterlasst bitte einfach einen Kommentar.
Teilt diese Seite mit euren Freunden und besucht uns mal auf Facebook und auf Google+, das würde dieser Seite wirklich weiterhelfen, danke sehr. Auch ein Klick auf die Werbung hilft dabei, diese Seite am Laufen zu halten.
Quelle: Original Anleitung auf englisch von Kilobolt Studios