Wir haben vier Kleckse vorbereitet. Ladet sie euch herunter und kopiert sie in den drawable Ordner:

Für diese Kleckse brauchen wir außerdem eine Klasse TempSprite:

package com.panjutorials.lazypudding;

import java.util.List;
import android.graphics.Bitmap;
import android.graphics.Canvas;

public class TempSprite {

	private float x;
	private float y;
	private Bitmap bmp;
	private int life = 20;
	private List<TempSprite> temps;

	public TempSprite(List<TempSprite> temps, GameView theGameView, float x, float y, Bitmap bmp) {
		this.x = Math.min(Math.max(x - bmp.getWidth() / 2, 0),
		theGameView.getWidth() - bmp.getWidth());
		this.y = Math.min(Math.max(y - bmp.getHeight() / 2, 0),
		theGameView.getHeight() - bmp.getHeight());
		this.bmp = bmp;
		this.temps = temps;
	}

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

	private void update() {
		if (--life < 1) {
			temps.remove(this);
		}
	}
}

In der der Konstruktor eine Liste an Temporären Sprites, ein Objekt unseres GameViews, außerdem die x und y Position und eine Bitmap als Parameter hat. In der (in früheren Versionen hieß es noch onDraw() Methode dieser Klasse wird unsere Bitmap auf den Canvas gemalt, und zwar an der Position x und y die dem Objekt bei seiner Erstellung (in der GameView Klasse) übergeben werden.

Außerdem wird die Methode update() aufgerufen, welche die Variable life(die wir mit 20 initialisiert haben) bei jedem aufruf herunterzählt und sobald sie bei Null angekommen ist den Klecks löscht. Da die update() Methode bei jedem aufruf der (in früheren Versionen hieß es noch onDraw() Methode aufgerufen wird, wird der temporäre Sprite recht schnell gelöscht, in unserem Fall nach etwas weniger als einer Sekunde.

Mit...

this.x = Math.min(Math.max(x - bmp.getWidth() / 2, 0), theGameView.getWidth() - bmp.getWidth());

... sorgen wir dafür, dass unser temporärer Sprite nicht unmittelbar an der Stelle die berührt wurde auftaucht, sondern um die hälfte der Höhe und Breite des Bildes verschoben. Das führt dazu, dass das Bild so gemalt wird, als wäre der Berührpunkt in der Mitte davon. Siehe Bild:

Damit die Kleckse nun noch auf den Canvas des Gameviews gemalt werden, müssen wir vier neue Bitmaps und eine Liste vom TempSprite Objekten anlegen:

private Bitmap bmpBlueTemp, bmpRedTemp, bmpGreenTemp, bmpYellowTemp;
private List<TempSprite> temps = new ArrayList<TempSprite>();

Dann müssen wir die Bitmaps in unserem Konstruktor des GameViews setzen.

bmpBlueTemp = BitmapFactory.decodeResource(getResources(), R.drawable.tmpblue);
bmpRedTemp = BitmapFactory.decodeResource(getResources(), R.drawable.tmpred);
bmpYellowTemp = BitmapFactory.decodeResource(getResources(), R.drawable.tmpyellow);
bmpGreenTemp = BitmapFactory.decodeResource(getResources(), R.drawable.tmpgreen);

Dabei initalisieren wir die Bitmaps mit den vorher heruntergeladenen Bildern.

Um nun zu bestimmen welcher der temporären Sprites auftauchen soll, brauchen wir folgende Methode:

public void checkColorTouched(int i, float x, float y){
	if (spriteListNum.get(i) == 0)
		temps.add(new TempSprite(temps, this,
				x, y, bmpBlueTemp));
	else if (spriteListNum.get(i) == 1)
		temps.add(new TempSprite(temps, this,
				x, y, bmpRedTemp));
	else if (spriteListNum.get(i) == 2)
		temps.add(new TempSprite(temps, this,
				x, y, bmpGreenTemp));
	else if (spriteListNum.get(i) == 3)
		temps.add(new TempSprite(temps, this,
				x, y, bmpYellowTemp));
}

Als Paramter hat diese Methode den Index und die x und y Position. In dieser Methode fragen wir ab, welche der Zahlen 0 bis 3 unsere Variable spriteListNum.get(i), also die Farbennummer, hat. Wobei 0 für Blau, 1 für Rot, 2 für Grün und 3 für Gelb steht. Der Nummer entsprechend wird der richtige temporäre Sprite(Klecks) gewählt.

Diese Methode checkColorTouched müssen wir nun in unserer onTouchEvent() Methode aufrufen, und zwar direkt bevor wir deleteSprite(i); ausführen:

checkColorTouched(i,event.getX(),event.getY());

Übergeben müssen wir ihr den Index(dadurch wird die passende Farbe bestimmt), und die Position unserer Berührung via event.getX() und event.getY().

Natürlich dürfen wir nicht vergessen die Kleckse nun auch tatsächlich auf unseren Canvas zu malen. Dazu müssen wir eine for Schleife in der onDraw() Methode der GameView Klasse aufrufen:

for (int i = temps.size() - 1; i >= 0; i--) {
	temps.get(i).draw(canvas);
}

Hierbei ist es wichtig, dass diese for Schleife vor den for Schleifen unserer Sprites und Heartsprites eingefügt werden, da die Kleckse sonst über unseren Sprites gemalt werden würden.

Damit hätten wir erreicht, dass bei jedem berühren eines Sprites(außer bei Heartsprite), ein Klecks mit der Farbe des Sprites, der berührt wurde, auf dem Bildschirm auftaucht, der für etwas unter einer Sekunde bestand hat und danach verschwindet.