Jetzt werden wir einige Konzepte anwenden, welche in den vorhergehenden Lektionen behandelt wurden, um unser Spiel mit einem scrollbaren Hintergrund auszustatten. Des Weiteren werden wir die Bewegung unserer Spielfigur noch ein wenig bearbeiten. Ziel ist es, das Ducken zu erlernen und das Hüpfen vorzubereiten.

Stunde #2-13: Bewegter Hintergrund Teil 1

Hierzu erstellen wir eine neue Klasse und nennen diese Background.

Innerhalb dieser neuen Klasse werden wir:

1. Variablen erstellen, die uns erlauben, den Hintergrund zu manipulieren.

2. Wir definieren einen Konstrukteur (constructor), welcher uns erlaubt, ein Objekt mit der Background Klasse zu erstellen. Erinnert euch daran, dass Klassen ein Entwurf bzw. Plan für Objekte sind. Wir verweisen auf ein Objekt, welches mithilfe einer Klasse erstellt wird und mit deren Eigenschaften ausgestattet ist.

3. Wir erstellen eine update()-Methode, die uns den Hintergrund bewegen lässt.

4. Es werden Getters und Setters hinzugefügt, welche mit den Variablen in Punkt 1 zu tun haben. Erinnert euch an Lektion 4 – Getters und Setters sind Hilfsmethoden, die es uns ermöglichen, private (klasseninterne) Variablen abzurufen und zu verändern.

I. Erstellen von Variablen

Wir werden bgX, bgY und speedX erstellen. bgX und bgY geben uns die Koordinaten von der linken oberen Ecke des Hintergrunds an. Um diese nun hinzuzufügen, müssen wir nur Folgendes in unsere Klasse einfügen:

package basteldroid;

public class Background {

	<strong>private int bgX, bgY, speedX;</strong>

}

package basteldroid;

public class Background {

private int bgX, bgY, speedX;

}

II . Definition des Konstrukteurs

Als wir unseren Roboter erschufen, brachten wir alle Dinge, die damit zu tun haben, in der Robot Klasse unter. Genau dies tun wir nun auch mit unserem Hintergrund.

Um den Hintergrund zu erzeugen, benötigen wir einen Konstrukteur. Diesen erstellen wir gleich nach der Variablendeklaration. Jetzt überlegen wir uns, welche Variablen wir brauchen könnten, um ein Hintergrundobjekt zu erzeugen. Falls wir neue Hintergrundobjekte erzeugen, machen wir das wahrscheinlich an einer konkreten Position, welche wir bestimmen. Daher fügen wir zwei Parameter hinzu – einen für die X- und einen für die Y-Koordinate:

package basteldroid;

public class Background {

	private int bgX, bgY, speedX;

	public Background (int x, int y){
		   bgX = x;
		   bgY = y;
		   speedX = 0;
		}

}

package basteldroid;

public class Background {

private int bgX, bgY, speedX;

public Background (int x, int y){

bgX = x;

bgY = y;

speedX = 0;

}

Die drei von uns erzeugten Variablen haben zu Beginn alle den Wert 0. Der Hintergrund soll am Anfang oben links in der Ecke beginnen und sich nicht bewegen, da sich der Roboter erst bewegen muss, um die Hintergrundbewegung zu rechtfertigen. Die StartingClass wird dann neue Werte liefern.

III. update()-Methode

Mit jedem Durchlauf unserer Spielschleife, alle 17 Millisekunden, müssen wir etwas mit unserem Hintergrund anstellen. In unserem Spiel soll der Hintergrund sich erst dann bewegen, wenn unser Roboter sich nach rechts bewegt. Also müssen wir eine update()-Methode erstellen, welche die benötigten Änderungen zu unserem Hintergrund übernimmt.

In dieser Lektion werden wir einen unendlichen Hintergrund erstellen, welcher sich aus zwei langen Bildern ergibt und immer wieder in einer Schleife ausgeführt wird: 1, 2, 1, 2, 1, 2, 1, …

Was benötigt nun unsere update()-Methode:

1. Sie sollte die Position immer aktuell halten.

2. Wenn unser Hintergrundbild nicht mehr angezeigt werden kann, sollte die Methode aufhören zu arbeiten (um Speicher zu sparen) oder das Hintergrundbild erneut anzeigen.

Momentan werden wir ein Hintergrundbild mit den Abmessungen von 2160 x 480 verwenden.

package basteldroid;

public class Background {

	private int bgX, bgY, speedX;

	public Background (int x, int y){
		   bgX = x;
		   bgY = y;
		   speedX = 0;
		}

	public void update() {
		   bgX += speedX;

		   if (bgX &lt;= -2160){
		      bgX += 4320;
		   }
		}

}

package basteldroid;

public class Background {

private int bgX, bgY, speedX;

public Background (int x, int y){

bgX = x;

bgY = y;

speedX = 0;

}

public void update() {

bgX += speedX;

if (bgX <= -2160){

bgX += 4320;

}

Kurze Anmerkung:

Unerfahrene Programmierer fragen häufig, ob der Name einer Methode durch Java vordefiniert ist oder man diesen willkürlich wählen kann? In diesem Fall erstellen wir eine neue Methode mit dem Namen update, dies ist unsere freie Wahl. Aber wenn wir uns immer wieder auf die StartingClass beziehen, können sich die Namen nicht ändern. Das ergibt sich daraus, dass wir die Methoden von Superklassen und Interfaces ausleihen. Wenn @Override vor einer Methode steht, bedeutet dies, benutze die neue Definition, nicht die aus der Superklasse. Beim Importieren von Methoden nutzt die Hilfe von Eclipse, dort lassen sich viele nützliche Informationen finden.

Kurze Anmerkung 2:

Denkt nach über das, was ihr programmiert. Nehmt nicht einfach alles so hin, was ich schreibe. Ihr müsst die Zusammenhänge verstehen, wie alles mit einander arbeitet. Je mehr ihr dies versteht, desto eher könnt ihr eure eigenen Programme entwickeln. Also falls ihr Fragen habt, stellt diese auch, ich versuche jedem zu helfen und freue mich auch darüber.

Nachdem jeder sich ein Bild von der update()-Methode gemacht hat, lasst uns mal einen Blick darauf werfen, was wir hier gemacht haben.

Mit bgX += speedX ändern wir die Geschwindigkeit unserer Bewegung, was Sinn macht. Je weiter sich nun der Roboter nach rechts bewegt, desto weiter rutscht die obere linke Ecke unseres Hintergrundbildes nach links, dass bedeutet, sie wandert aus dem Bildschirm raus und wird negativ.

Wenn nun die X-Koordinate bei -2160 angelangt ist oder darunter (damit wäre das Bild auf der rechten Seite nicht mehr komplett im Bildschirm), schieben wir diese um 4320 Pixel nach rechts. Wenn wir den Code dann durchlaufen lassen, macht alles einen Sinn.

Warum schreiben wir nun aber bgX <= -2160 nicht bgX == -2160?

Dies ist sehr wichtig, dass wir das wissen. Was wäre, wenn die Geschwindigkeit unseres Hintergrundes kein Faktor von 2160 ist? Welcher ist der kleinste Wert, der unsere X-Position ändert? Kann sich bgX von 2161 auf 2159 ändern? Ist unser Code dann noch richtig?

IV. Getters und Setters

Das ist einfach, da Eclipse uns hier die komplette Arbeit abnimmt. Dazu machen wir einen Rechtsklick irgendwo in den Weißraum neben dem Code unserer Background Klasse und wählen Source > Generate Getters and Setters…
Danach Select All und unter Sort by: First getters, then setters.

Nun haben wir folgenden Stand:

package basteldroid;

public class Background {

	private int bgX, bgY, speedX;

	public Background (int x, int y){
		   bgX = x;
		   bgY = y;
		   speedX = 0;
		}

	public void update() {
		   bgX += speedX;

		   if (bgX &lt;= -2160){
		      bgX += 4320;
		   }
		}

	public int getBgX() {
		return bgX;
	}

	public int getBgY() {
		return bgY;
	}

	public int getSpeedX() {
		return speedX;
	}

	public void setBgX(int bgX) {
		this.bgX = bgX;
	}

	public void setBgY(int bgY) {
		this.bgY = bgY;
	}

	public void setSpeedX(int speedX) {
		this.speedX = speedX;
	}

}

package basteldroid;

public class Background {

private int bgX, bgY, speedX;

public Background (int x, int y){

bgX = x;

bgY = y;

speedX = 0;

}

public void update() {

bgX += speedX;

if (bgX <= -2160){

bgX += 4320;

}

public int getBgX() {

return bgX;

}

public int getBgY() {

return bgY;

}

public int getSpeedX() {

return speedX;

}

public void setBgX(int bgX) {

this.bgX = bgX;

}

public void setBgY(int bgY) {

this.bgY = bgY;

}

public void setSpeedX(int speedX) {

this.speedX = speedX;

}

Stunde #2-14: Bewegter Hintergrund Teil 2

Nun haben wir unsere Background Klasse fertig erstellt und werden nun unsere zwei Hintergrundbilder hinzufügen. In dieser Stunde werden wir mit der StartingClass arbeiten, also öffnen wir diese.

Regel:

Immer wenn wir ein neues Objekt zu unserem Spiel hinzufügen, müssen wir Folgendes machen:

0. Wir erstellen eine neue Klasse dafür, welche wir als Vorlage für weitere Objekte nutzen können (wir taten das für die Background Klasse).

1. In der StartingClass müssen wir Objekte erstellen, welche auf unsere neue Klasse zugreifen. Als Erstes müssen wir sie als Variablen am Anfang der Klasse erstellen und als Zweites müssen wir in der start()-Methode darauf zurückgreifen.

2. In der run()-Methode müssen wir die update()-Methode aufrufen.

3. Wir müssen unser neues Objekt in der paint()-Methode darstellen lassen.

Da wir Punkt 0 schon im ersten Teil erstellt haben, werden wir uns nun Punkt 1 widmen.

I. Variablen erstellen und diese initialisieren

Dazu schreiben wir einfach unter die von uns bereits erstellten Variablen:

public class StartingClass extends Applet implements Runnable, KeyListener {

	private Robot robot;
	private Image image,character;
	private URL base;
	private Graphics second;
	private static Background bg1, bg2;

public class StartingClass extends Applet implements Runnable, KeyListener {

private Robot robot;

private Image image,character;

private URL base;

private Graphics second;

private static Background bg1, bg2;

Wir machen diese erstmal statisch, dass wir Getters und Setters benutzen können.

Um diese Variablen nun zu Initialisieren, nehmen wir folgende Änderungen an der start()-Methode vor:

	@Override
	public void start() {
		bg1 = new Background(0, 0);
		bg2 = new Background(2160, 0);
		robot = new Robot();

		// TODO Auto-generated method stub
		Thread thread = new Thread(this);
		thread.start();
	}

@Override

public void start() {

bg1 = new Background(0, 0);

bg2 = new Background(2160, 0);

robot = new Robot();

// TODO Auto-generated method stub

Thread thread = new Thread(this);

thread.start();

}

Dies erstelle 2 neue separate Hintergrundobjekte, welche wir als bg1 und bg2 bezeichnen. Erinnert euch daran, wir benötigen 2 integere Werte für unseren Hintergrundkonstrukteur, X und Y Koordinaten.

II. update()-Methode

Wir wollen nun, dass unsere 2 Hintergründe bei jedem Durchlauf der Schleife aktualisiert werden. Dazu ändern wir die run()-Methode wir folgt:

	@Override
	public void run() {
		// TODO Auto-generated method stub
		 while (true) {
			 bg1.update();
			 bg2.update();
			 robot.update();
		      repaint();

		         try {
					Thread.sleep(17);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

		   }

@Override

public void run() {

// TODO Auto-generated method stub

while (true) {

bg1.update();

bg2.update();

robot.update();

repaint();

try {

Thread.sleep(17);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

III. Den Hintergrund zeichnen

Nun wollen wir auch, dass unser Hintergrund angezeigt wird. Dazu ladet das Bild herunter und kopiert es in den data Ordner, wie in der vorherigen Lektion.

Als erstes müssen wir unsere Variablen bearbeiten:

public class StartingClass extends Applet implements Runnable, KeyListener {

	private Robot robot;
	private Image image,character,background;
	private URL base;
	private Graphics second;
	private static Background bg1, bg2;

public class StartingClass extends Applet implements Runnable, KeyListener {

private Robot robot;

private Image image,character,background;

private URL base;

private Graphics second;

private static Background bg1, bg2;

In der init()-Methode, wo wir unsere Bildeinstellungen vorgenommen haben, müssen wir auch unseren Hintergrund definieren:

	@Override
	public void init() {
		// TODO Auto-generated method stub
		setSize(800, 480);
		setBackground(Color.BLACK);
		setFocusable(true);
		addKeyListener(this);
		Frame frame = (Frame) this.getParent().getParent();
	    frame.setTitle("Q-Bot Alpha");
	    try {
			base = getDocumentBase();
		} catch (Exception e) {
			// TODO: handle exception
		}

		// Bildeinstellung
		character = getImage(base, "data/character.png");
		background = getImage(base, "data/background.png");
	}

@Override

public void init() {

// TODO Auto-generated method stub

setSize(800, 480);

setBackground(Color.BLACK);

setFocusable(true);

addKeyListener(this);

Frame frame = (Frame) this.getParent().getParent();

frame.setTitle("Q-Bot Alpha");

try {

base = getDocumentBase();

} catch (Exception e) {

// TODO: handle exception

}

// Bildeinstellung

character = getImage(base, "data/character.png");

background = getImage(base, "data/background.png");

}

Nun wollen wir unseren Hintergrund auch zeichnen lassen, dazu ändern wir die paint()-Methode. Bilder werden immer in der Reihenfolge angezeigt, wie sie im Code erscheinen. Wenn ich also unseren Roboter über dem Hintergrund darstellen möchte, muss der Hintergrund als Erstes erscheinen.

	@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);
		g.drawImage(character, robot.getCenterX() - 61, robot.getCenterY() - 63, this);
	}

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

g.drawImage(character, robot.getCenterX() - 61, robot.getCenterY() - 63, this);

}

Damit haben wir unseren Hintergrund in das Spiel eingefügt, noch passiert aber nichts damit. Daher müssen wir noch einige Änderungen an der StartingClass und der Robot Klasse vornehmen.

Stunde #2-15: Spielfigur bewegen

Momentan hält der Roboter an, sobald ich die rechts oder links Taste los lasse, auch wenn die andere betätigt ist. Dies macht die Bewegung sehr unkomfortabel und dadurch haben wir kein schönes Spiel.

Dieses Problem kann man aber einfach lösen. Wir werden nun einfach überprüfen, ob eine weitere Taste betätigt wurde, bevor unser Roboter anhält. Des Weiteren lassen wir unseren Roboter sich ducken, wobei er sich nicht bewegen kann.

Änderungen an der Robot Klasse

Wir werden nun einige Änderungen an der Robot Klasse vornehmen, daher werde ich hier den kompletten Code einfügen. Beim Durchgehen des Codes Zeile für Zeile, sollte sich eigentlich alles selbst erklären, falls jemand Fragen hat, bitte stellt diese auch. Ich habe die Getters und Setters auch an das Ende meines Codes verschoben, der Übersichtlichkeit Halber.

package basteldroid;

import java.awt.Graphics;

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;

	        	private static Background bg1 = StartingClass.getBg1();                 
	        	private static Background bg2 = StartingClass.getBg2();

		private int speedX = 0;
		private int speedY = 1;

		public void update() {

			// Bewegt den Roboter oder passt den Hintergrund an.
			 if (speedX &lt; 0) {
		            centerX += speedX;
		        }
		        if (speedX == 0 || speedX &lt; 0) {
		            bg1.setSpeedX(0);
		            bg2.setSpeedX(0);

		        }
		        if (centerX &lt;= 200 &amp;&amp; speedX &gt; 0) {
		            centerX += speedX;
		        }
		        if (speedX &gt; 0 &amp;&amp; centerX &gt; 200){
		            bg1.setSpeedX(-MOVESPEED);
		            bg2.setSpeedX(-MOVESPEED);
		        }

			// Update der Y-Position

		        centerY += speedY;
		        if (centerY + speedY &gt;= GROUND) {
		            centerY = GROUND;
		        }

			// Hier wird das Springen kontrolliert.
		        if (jumped == true) {
		            speedY += 1;

		            if (centerY + speedY &gt;= GROUND) {
		                centerY = GROUND;
		                speedY = 0;
		                jumped = false;
		            }
                            else {
                                  centerY += speedY;
                                  }

		        }

			// Verhindert, dass unsere Spielfigur einen gewissen Punkt
			// in X-Richtung überschreitet.
			if (centerX + speedX &lt;= 60) { 
			// Falls beim Addieren von speedX centerX auf kleiner als 60 fällt, 
		        // ist speedX = 61.
				centerX = 61;
			}
		}

		public void moveRight() {
			if (ducked == false) {
	            speedX = MOVESPEED;
	        }
		}

		public void moveLeft() {
			if (ducked == false) {
	            speedX = -MOVESPEED;
	        }
		}

		public void stop() {
                       if (isMovingRight() == false &amp;&amp; isMovingLeft() == false) {
                                 speedX = 0;
                            } else if (isMovingRight() == false &amp;&amp; isMovingLeft() == true) {
                                  moveLeft();
                            } else if (isMovingRight() == true &amp;&amp; isMovingLeft() == false) {
                                  moveRight();
                            }
                        }

		public void stopRight() {
	        setMovingRight(false);
	        stop();
	    }

	    public void stopLeft() {
	        setMovingLeft(false);
	        stop();
	    }

		public void jump() {
			if (jumped == false) {
	            speedY = JUMPSPEED;
	            jumped = true;
	        }

		}

                //ab hier Getters und Setters

		public int getJUMPSPEED() {
			return JUMPSPEED;
		}

		public int getMOVESPEED() {
			return MOVESPEED;
		}

		public int getGROUND() {
			return GROUND;
		}

		public int getCenterX() {
			return centerX;
		}

		public int getCenterY() {
			return centerY;
		}

		public boolean isJumped() {
			return jumped;
		}

		public boolean isMovingLeft() {
			return movingLeft;
		}

		public boolean isMovingRight() {
			return movingRight;
		}

		public boolean isDucked() {
			return ducked;
		}

		public static Background getBg1() {
			return bg1;
		}

		public static Background getBg2() {
			return bg2;
		}

		public int getSpeedX() {
			return speedX;
		}

		public int getSpeedY() {
			return speedY;
		}

		public void setCenterX(int centerX) {
			this.centerX = centerX;
		}

		public void setCenterY(int centerY) {
			this.centerY = centerY;
		}

		public void setJumped(boolean jumped) {
			this.jumped = jumped;
		}

		public void setMovingLeft(boolean movingLeft) {
			this.movingLeft = movingLeft;
		}

		public void setMovingRight(boolean movingRight) {
			this.movingRight = movingRight;
		}

		public void setDucked(boolean ducked) {
			this.ducked = ducked;
		}

		public static void setBg1(Background bg1) {
			Robot.bg1 = bg1;
		}

		public static void setBg2(Background bg2) {
			Robot.bg2 = bg2;
		}

		public void setSpeedX(int speedX) {
			this.speedX = speedX;
		}

		public void setSpeedY(int speedY) {
			this.speedY = speedY;
		}

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

package basteldroid;

import java.awt.Graphics;

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;

private static Background bg1 = StartingClass.getBg1();

private static Background bg2 = StartingClass.getBg2();

private int speedX = 0;

private int speedY = 1;

public void update() {

// Bewegt den Roboter oder passt den Hintergrund an.

if (speedX < 0) {

centerX += speedX;

}

if (speedX == 0 || speedX < 0) {

bg1.setSpeedX(0);

bg2.setSpeedX(0);

}

if (centerX <= 200 && speedX > 0) {

centerX += speedX;

}

if (speedX > 0 && centerX > 200){

bg1.setSpeedX(-MOVESPEED);

bg2.setSpeedX(-MOVESPEED);

}

// Update der Y-Position

centerY += speedY;

if (centerY + speedY >= GROUND) {

centerY = GROUND;

}

// Hier wird das Springen kontrolliert.

if (jumped == true) {

speedY += 1;

if (centerY + speedY >= GROUND) {

centerY = GROUND;

speedY = 0;

jumped = false;

}

else {

centerY += speedY;

}

// Verhindert, dass unsere Spielfigur einen gewissen Punkt

// in X-Richtung überschreitet.

if (centerX + speedX <= 60) {

// Falls beim Addieren von speedX centerX auf kleiner als 60 fällt,

// ist speedX = 61.

centerX = 61;

}

public void moveRight() {

if (ducked == false) {

speedX = MOVESPEED;

}

public void moveLeft() {

if (ducked == false) {

speedX = -MOVESPEED;

}

public void stop() {

if (isMovingRight() == false && isMovingLeft() == false) {

speedX = 0;

} else if (isMovingRight() == false && isMovingLeft() == true) {

moveLeft();

} else if (isMovingRight() == true && isMovingLeft() == false) {

moveRight();

}

public void stopRight() {

setMovingRight(false);

stop();

}

public void stopLeft() {

setMovingLeft(false);

stop();

}

public void jump() {

if (jumped == false) {

speedY = JUMPSPEED;

jumped = true;

}

//ab hier Getters und Setters

public int getJUMPSPEED() {

return JUMPSPEED;

}

public int getMOVESPEED() {

return MOVESPEED;

}

public int getGROUND() {

return GROUND;

}

public int getCenterX() {

return centerX;

}

public int getCenterY() {

return centerY;

}

public boolean isJumped() {

return jumped;

}

public boolean isMovingLeft() {

return movingLeft;

}

public boolean isMovingRight() {

return movingRight;

}

public boolean isDucked() {

return ducked;

}

public static Background getBg1() {

return bg1;

}

public static Background getBg2() {

return bg2;

}

public int getSpeedX() {

return speedX;

}

public int getSpeedY() {

return speedY;

}

public void setCenterX(int centerX) {

this.centerX = centerX;

}

public void setCenterY(int centerY) {

this.centerY = centerY;

}

public void setJumped(boolean jumped) {

this.jumped = jumped;

}

public void setMovingLeft(boolean movingLeft) {

this.movingLeft = movingLeft;

}

public void setMovingRight(boolean movingRight) {

this.movingRight = movingRight;

}

public void setDucked(boolean ducked) {

this.ducked = ducked;

}

public static void setBg1(Background bg1) {

Robot.bg1 = bg1;

}

public static void setBg2(Background bg2) {

Robot.bg2 = bg2;

}

public void setSpeedX(int speedX) {

this.speedX = speedX;

}

public void setSpeedY(int speedY) {

this.speedY = speedY;

}

Änderungen:

1. Wir haben bisher noch nicht über Konstanten gesprochen, also werden wir das mal nachholen. Konstanten sind eine Art von Variablen. Wie der Name schon sagt, ist der Wert immer gleich, also konstant.

Um zu sagen, was konstant ist, benutzen wir das Wort final (deshalb kann dieses Wort auch niemals für eine Variable genutzt werden), und da es unter Programmierern Brauch ist (kein Gesetz), schreiben wir Konstanten komplett in Großbuchstaben.

final int JUMPSPEED = -15;
final int MOVESPEED = 5;
final int GROUND = 382;

Diese drei Zeilen Code zeigen unsere Konstanten. Bisher haben wir bei jeder Bewegung immer wieder die Zahlen -15, 5 und 382 geschrieben, mit diesen Konstanten können wir die Zahlen vergessen und müssen nur die Konstanten schreiben.

2. System.out.println() hat uns angezeigt, dass der Hintergrund sich eigentlich bewegen sollte. Diese Platzhalter wurden nun entfernt und mit dem Code ersetzt, welcher wirklich den Hintergrund bewegt.

3. Die boolean Variablen sind dazu da, unsere Bewegung zu verfolgen. Jedesmal wenn wir uns nach links und nach rechts bewegen, speichern es diese Variablen.

Zum Beispiel: Wenn wir uns nach links bewegen und die linke Taste betätigen (movingLeft == true) und wir uns gleichzeitig nach rechts bewegen und die rechte Taste betätigen (movingRight == true) und nun eine der beiden Tasten losließen, würde unser Roboter anhalten. Jetzt, mit den Änderungen, wird erst überprüft, ob eine der Richtungen noch betätigt wird, damit stehen nun zwei Möglichkeiten zur Auswahl: 1. Falls die andere Taste nicht betätigt wird, stoppe den Roboter. 2. Falls die andere Taste betätigt wird, bewege dich in diese Richtung.

4. Wenn wir in unserer Robot Klasse Änderungen vornehmen, werden wir in der StartingClass Fehler erhalten. Diese werden wir noch beheben.

Änderungen an der StartingClass

Diese Änderungen werden nur in den keyPressed() und keyReleased() Methoden vorgenommen. Dies ist so, weil die Bewegung unserer Spielfigur nur hier behandelt wird. Ich habe hier den Code komplett rein kopiert.

@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:
			  <span style="color: #ff0000"> currentSprite = characterDown;
	            if (robot.isJumped() == false){
	                robot.setDucked(true);
	                robot.setSpeedX(0);</span>
	            }
		   break;

		   case KeyEvent.VK_LEFT:
			   robot.moveLeft();
			   <span style="color: #ff0000">robot.setMovingLeft(true);</span>
		   break;

		   case KeyEvent.VK_RIGHT:
			   robot.moveRight();
			   <span style="color: #ff0000">robot.setMovingRight(true);</span>
		   break;

		   case KeyEvent.VK_SPACE:
			   robot.jump();
		   break;
		   }
	}

	@Override
	public void keyReleased(KeyEvent e) {
		// TODO Auto-generated method stub
		switch (e.getKeyCode()) {
		   case KeyEvent.VK_UP:
			   System.out.println("Stop dich zu bewegen");
		      break;

		   case KeyEvent.VK_DOWN:
			   <span style="color: #ff0000">currentSprite = character;
	            robot.setDucked(false);</span>
		      break;

		   case KeyEvent.VK_LEFT:
			   <span style="color: #ff0000">robot.stopLeft();</span>
		      break;

		   case KeyEvent.VK_RIGHT:
			   <span style="color: #ff0000">robot.stopRight();</span>
		      break;

		   case KeyEvent.VK_SPACE:
			  break;

		   }
	}

@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;

}

@Override

public void keyReleased(KeyEvent e) {

// TODO Auto-generated method stub

switch (e.getKeyCode()) {

case KeyEvent.VK_UP:

System.out.println("Stop dich zu bewegen");

break;

case KeyEvent.VK_DOWN:

currentSprite = character;

robot.setDucked(false);

break;

case KeyEvent.VK_LEFT:

robot.stopLeft();

break;

case KeyEvent.VK_RIGHT:

robot.stopRight();

break;

case KeyEvent.VK_SPACE:

break;

}

Die Fehler, welche nun auftreten, werden wir nachfolgend alle abarbeiten.

Stunde #2-16: Bewegungen

Nun werden wir unseren Roboter springen und sich ducken lassen, dazu benötigen wir die beiden neuen Bilder. Ladet die Bilder herunter und kopiert diese dann in den data Ordner unseres Spiels.

1. Nun müssen wir diese beiden Bilder als Variable erzeugen:

public class StartingClass extends Applet implements Runnable, KeyListener {

	private Robot robot;
	private Image image, <span style="color: #ff0000">currentSprite,</span> character, <span style="color: #ff0000">characterDown, characterJumped,</span> background;
	private URL base;
	private Graphics second;
	private static Background bg1, bg2;

public class StartingClass extends Applet implements Runnable, KeyListener {

private Robot robot;

private Image image, currentSprite, character, characterDown, characterJumped, background;

private URL base;

private Graphics second;

private static Background bg1, bg2;

Wir haben nun characterDown zum Ducken und characterJumped zum Hüpfen als Variable eingefügt, aber was ist currentSprite? Momentan zeichnen wir Robot robot mit dem Bild character. Nun wollen wir aber currentSprite zeichnen lassen, dies kann dynamisch zwischen unseren drei Bildern wählen, je nachdem, was unser Roboter macht.

2. Nun müssen wir noch unter den Bildeinstellungen unsere neuen Bilder einfügen und auch currentSprite.

@Override
	public void init() {
		// TODO Auto-generated method stub
		setSize(800, 480);
		setBackground(Color.BLACK);
		setFocusable(true);
		addKeyListener(this);
		Frame frame = (Frame) this.getParent().getParent();
	    frame.setTitle("Q-Bot Alpha");
	    try {
			base = getDocumentBase();
		} catch (Exception e) {
			// TODO: handle exception
		}

		<span style="color: #ff0000">// Bildeinstellung
	    character = getImage(base, "data/character.png");
	    characterDown = getImage(base, "data/down.png");
	    characterJumped = getImage(base, "data/jumped.png");
	    currentSprite = character;
	    background = getImage(base, "data/background.png");</span>
	}

@Override

public void init() {

// TODO Auto-generated method stub

setSize(800, 480);

setBackground(Color.BLACK);

setFocusable(true);

addKeyListener(this);

Frame frame = (Frame) this.getParent().getParent();

frame.setTitle("Q-Bot Alpha");

try {

base = getDocumentBase();

} catch (Exception e) {

// TODO: handle exception

}

// Bildeinstellung

character = getImage(base, "data/character.png");

characterDown = getImage(base, "data/down.png");

characterJumped = getImage(base, "data/jumped.png");

currentSprite = character;

background = getImage(base, "data/background.png");

}

3. Anpassen der run()-Methode

	@Override
	public void run() {
		// TODO Auto-generated method stub
		 while (true) {
			 bg1.update();
			 bg2.update();
			 robot.update();
			 <span style="color: #ff0000">if (robot.isJumped()){
					currentSprite = characterJumped;
				}else if (robot.isJumped() == false &amp;&amp; robot.isDucked() == false){
					currentSprite = character;
				}</span>
		      repaint();

		         try {
					Thread.sleep(17);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

		   }

	}

@Override

public void run() {

// TODO Auto-generated method stub

while (true) {

bg1.update();

bg2.update();

robot.update();

if (robot.isJumped()){

currentSprite = characterJumped;

}else if (robot.isJumped() == false && robot.isDucked() == false){

currentSprite = character;

}

repaint();

try {

Thread.sleep(17);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

Dieser Code wird immer wieder nach dem Status unseres Roboters schauen und currentSprite danach ausrichten, laufen, hüpfen oder ducken.

4. Nun müssen wir noch ändern, dass für unseren Roboter currentSprite angezeigt wird und nicht character.

@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);
		g.drawImage(<span style="color: #ff0000">currentSprite</span>, robot.getCenterX() - 61, robot.getCenterY() - 63, this);
	}

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

g.drawImage(currentSprite, robot.getCenterX() - 61, robot.getCenterY() - 63, this);

}

5. Als Letztes gehen wir ans Ende der Klasse und fügen neue Getters und Setters hinzu. Diesmal aber nur Getters für bg1 und bg2.

	public static Background getBg1() {
		return bg1;
	}

	public static Background getBg2() {
		return bg2;
	}

public static Background getBg1() {

return bg1;

}

public static Background getBg2() {

return bg2;

}

Damit sind wir auch schon am Ende der Lektion angekommen. Unser Hintergrund bewegt sich und unser Roboter kann sich mittlerweile schon ducken. Das Springen werden wir zu einem späterem Zeitpunkt hinzufügen. In der nächsten Lektion werden wir ein paar Gegner hinzufügen.

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.

Lektion 5

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

Lektion 4 – Spielfigur einbinden Teil 2 Lektion 6 – Gegner

Basteldroid

Kapitel 2 Lektion 5 – Hintergrund und Bewegungen

Stunde #2-13: Bewegter Hintergrund Teil 1

I. Erstellen von Variablen

II . Definition des Konstrukteurs

III. update()-Methode

Kurze Anmerkung:

Kurze Anmerkung 2:

IV. Getters und Setters

Stunde #2-14: Bewegter Hintergrund Teil 2

Regel:

I. Variablen erstellen und diese initialisieren

II. update()-Methode

III. Den Hintergrund zeichnen

Stunde #2-15: Spielfigur bewegen

Änderungen an der Robot Klasse

Änderungen:

Änderungen an der StartingClass

Stunde #2-16: Bewegungen

Source Code