Viele Dinge merken

Vierzig Variablen wären zu viel

Am Ende des letzten Kapitels blieb eine Frage offen. Du kannst jetzt prüfen, ob ein Ball einen Block trifft. Aber eine Breakout-Mauer hat vierzig Blöcke, und jeder muss einzeln verschwinden können, wenn er getroffen wird — die anderen neununddreißig bleiben stehen.

Genau dieses Problem löst ein Array: eine einzige Variable, die sich nicht einen, sondern viele Werte merkt — durchnummeriert, damit eine Schleife darüber laufen kann.

Ein Array anlegen

boolean[] nochDa = new boolean[40];

Das legt Platz für 40 Werte an, alle vom selben Typ. Auf einen einzelnen Wert kommst du über seinen Index in eckigen Klammern — und die Zählung beginnt bei 0, nicht bei 1:

int[] hoehen = new int[5];

void setup() {
size(340, 160);
background(250);

fill(40);
textSize(16);
text("hoehen[0] ist " + hoehen[0], 20, 40);
text("hoehen.length ist " + hoehen.length, 20, 70);
}

Füllen und durchgehen

Feste Werte gibst du direkt beim Anlegen an. Sollen sie erst berechnet werden — etwa zufällig —, füllst du sie mit einer Schleife:

int[] hoehen = new int[8];

void setup() {
size(360, 240);

for (int i = 0; i < hoehen.length; i++) {
  hoehen[i] = int(random(30, 180));
}
}

void draw() {
background(250);
noStroke();
fill(70, 130, 220);

for (int i = 0; i < hoehen.length; i++) {
  rect(20 + i * 40, 220 - hoehen[i], 30, hoehen[i]);
}
}

Zwei Schleifen mit demselben Muster for (int i = 0; i < hoehen.length; i++): Die erste füllt das Array einmalig in setup(), die zweite liest es bei jedem Bild wieder aus, um zu zeichnen. Das Array merkt sich die Werte dazwischen — bei fünf oder achtzig Elementen genau gleich.

Jetzt verbindest du das mit dem Abprall aus Kapitel 3. Statt einer einzigen x-Variablen bekommt jeder Ball seinen eigenen Platz im Array — und dieselbe Schleife bewegt und prüft sie alle:

int anzahl = 5;
float[] x = new float[anzahl];
float[] tempo = new float[anzahl];
float radius = 16;

void setup() {
size(400, 260);
for (int i = 0; i < anzahl; i++) {
  x[i] = random(radius, width - radius);
  tempo[i] = random(1, 4);
}
}

void draw() {
background(250);
noStroke();
fill(70, 130, 220);

for (int i = 0; i < anzahl; i++) {
  x[i] = x[i] + tempo[i];

  if (x[i] > width - radius || x[i] < radius) {
    tempo[i] = -tempo[i];
  }

  circle(x[i], 40 + i * 45, radius * 2);
}
}

Die Grenze eines Arrays

Ein Array hat eine Schwäche: Seine Größe steht fest, sobald du es mit new int[5] anlegst. Für „vierzig Blöcke, die die ganze Zeit da sind" reicht das — die Anzahl ändert sich ja nie, nur ihr Zustand (noch da oder zerstört).

Für „Projektile, die beim Schießen entstehen und beim Verlassen der Fläche wieder verschwinden" reicht ein Array nicht mehr, denn dort ändert sich die Anzahl laufend. Dafür gibt es eine zweite Datenstruktur: die ArrayList. Sie funktioniert wie ein Array, das mitwächst und mitschrumpft.

ArrayList: wächst und schrumpft

ArrayList<PVector> projektile = new ArrayList<PVector>();

void mousePressed() {
  // Ein neues Projektil entsteht - die Liste wird um eins laenger.
  projektile.add(new PVector(mouseX, mouseY));
}

void draw() {
  background(250);

  for (int i = 0; i < projektile.size(); i++) {
    PVector p = projektile.get(i);
    p.y = p.y - 4;   // fliegt nach oben
    circle(p.x, p.y, 12);
  }
}

AufgabenBaue Arrays in dein Spiel ein

Was noch fehlt

Jetzt hast du mehrere Ziele, mehrere Blöcke, mehrere Bälle — alle sauber in Arrays organisiert, statt in vierzig einzelnen Variablen. Dein Spiel reagiert bisher aber nur auf Maus und Klick.

Für Pong und Breakout fehlt noch die Tastatur — ein Schläger, der sich mit den Pfeiltasten bewegt, statt der Maus zu folgen. Und für ein fertiges Spielgefühl fehlen Bilder und Sound. Genau darum geht es im nächsten Kapitel.