Ein Sprite ist ein Grafikobjekt das über das Hintergrundbild bzw. den restlichen Inhalt der Bildschirmanzeige eingeblendet wird. Es hat eine x-Achsen und ein y-Achsen Position. und in unserem Fall auch eine Geschwindigkeit in beide Richtungen.

Um nun das Bild was wir in den letzten Tutorials bewegt haben durch Sprites zu ersetzen, erstellen wir eine Klasse Sprite.

In der wir einige globale Variablen anlegen:

private int x = 0;
private int y = 0;
private int xSpeed;
private int ySpeed;
private int width;
private int height;
private Bitmap bmp;
private GameView theGameView;

Dabei ist x die Position in die horizontale Richtung und y die Position in vertikale Richtung. Dem entsprechen sind xSpeed und ySpeed die Geschwindigkeiten in die jeweilige richtung. width und height sollen als Variable für die Breite und Höhe des Sprites dienen. bmp ist die Bitmap also das Bild das wir für unseren Sprite verwenden.

Dann erstellen wir einen Konstruktor, dem wir die Gameview und das Bild, das wir für den Sprite verwenden wollen, übergeben.

Mit...

this.theGameView = theGameView;
this.bmp = bmp;
this.width = bmp.getWidth();
this.height = bmp.getHeight();

... legen wir fest, welcher GameView verwendet werden soll, welches Bild und dass die Variablen width und height die Breite und Höhe des Bildes sein soll.

Damit die Sprites sich mit einer zufälligen Geschwindigkeit in einem bestimmten Rahmen bewegen, benötigen wir folgende drei Zeilen:

Random rnd = new Random();
ySpeed = rnd.nextInt(10) - 4;
xSpeed = rnd.nextInt(10) - 4;

Dabei legen wir eine Instanz des Zufallsgenerators an und legen dann die Geschwindigkeiten ySpeed und xSpeed fest, wobei sie zwischen 6 und -4 liegen können. Da rnd.nextInt(10) maximal 10 ist und minimal 0 und wir 4 abziehen.

Damit die Sprites nicht durch die Wand verschwinden, sondern an den Wänden abprallen, benötigen wir die folgende Methode:

private void bounceOff() {
	if (x > theGameView.getWidth() - width - xSpeed || x + xSpeed < 0) {
		xSpeed = -xSpeed;
	}
	x = x + xSpeed;
	if (y > theGameView.getHeight() - height - ySpeed || y + ySpeed < 0) {
		ySpeed = -ySpeed;
	}
	y = y + ySpeed;
}

Dabei sagen wir, dass wenn die Position des Sprites größer ist als die eigene Höhe/Breite minus die Höhe/Breite des Bildschirms minus die Geschwindigkeit in Höhen-/Breitenrichtung, soll die Geschwindigkeit umgekehrt werden. Danach wird die neue Position noch gesetzt, die der alten Position plus der Geschwindigkeit entspricht.

Dann benötigen wir nur noch die onDraw Methode- in der wir die Richtung der Geschwindigkeit mit dem Aufruf der Methode bounceOff() berechnen und das Bild an der passenden Position malen.

public void onDraw(Canvas canvas){
	bounceOff();
	canvas.drawBitmap(bmp, x, y, null);
}

Außerdem müssen wir Änderungen an unserer GameView Klasse vornehmen. Und zwar legen wir dafür zwei Variablen vom Typen Sprite global an:

private Sprite theSprite, theSprite2;

Danach erstellen wir zwei Objekte vom Typen Sprite in unserem Konstruktor...

theSprite = new Sprite(this, bmp);
theSprite2 = new Sprite(this, bmp);

... und malen die Beiden auf den Canvas via:

theSprite.onDraw(canvas);
theSprite2.onDraw(canvas);

Am ende Sollte die Sprite Klasse folgendermaßen aussehen:

package com.panjutorials.lazypudding;

import java.util.Random;

import android.graphics.Bitmap;
import android.graphics.Canvas;

public class Sprite {
	private int x = 0;
	private int y = 0;
	private int xSpeed;
	private int ySpeed;
	private int width;
	private int height;
	private Bitmap bmp;
	private GameView theGameView;

	public Sprite(GameView theGameView, Bitmap bmp) {
		this.theGameView = theGameView;
		this.bmp = bmp;
		this.width = bmp.getWidth();
		this.height = bmp.getHeight();
		Random rnd = new Random();
		ySpeed = rnd.nextInt(10) - 4;
		xSpeed = rnd.nextInt(10) - 4;
	}

	private void bounceOff() {
		if (x > theGameView.getWidth() - width - xSpeed || x + xSpeed < 0) {
			xSpeed = -xSpeed;
		}
		x = x + xSpeed;
		if (y > theGameView.getHeight() - height - ySpeed || y + ySpeed < 0) {
			ySpeed = -ySpeed;
		}
		y = y + ySpeed;
	}

	public void onDraw(Canvas canvas) {
		bounceOff();
		canvas.drawBitmap(bmp, x, y, null);
	}
}