Testat 1

oldY = 500/2;

stroke(0);

line(width-step, oldY, width, y);

1. stroke(0);: Setzt die Farbe der Linien auf Schwarz.

2. line(width-step, oldY, width, y);: Zeichnet eine Linie von der vorherigen y-Koordinate (oldY) zur neuen y-Koordinate (y) am rechten Rand der Leinwand.

oldY = y;: Aktualisiert oldY auf die aktuelle y-Koordinate für den nächsten Frame.

copy(step, 0, width - step, height, 0, 0, width-step, height);

Diese Zeile kopiert einen Bereich der Leinwand und verschiebt ihn nach links. Die Parameter sind:

• step: Die x-Koordinate des zu kopierenden Bereichs (beginnend einen Schritt vom linken Rand entfernt).

• 0: Die y-Koordinate des zu kopierenden Bereichs (beginnend am oberen Rand).

• width - step: Die Breite des zu kopierenden Bereichs (die gesamte Breite der Leinwand minus einen Schritt).

• height: Die Höhe des zu kopierenden Bereichs (die gesamte Höhe der Leinwand).

• 0, 0: Die x- und y-Koordinaten des Ziels, wohin der kopierte Bereich verschoben wird (beginnend am linken Rand).

• width-step, height: Die Breite und Höhe des Zielbereichs, die dieselben Maße wie der Quellbereich haben.

noStroke();

fill(255);

rect(width - step, 0, step, height);

noStroke(); fill(255); rect(width - step, 0, step, height);: Löscht den rechten step-breiten Streifen, indem ein weißes Rechteck darüber gezeichnet wird.

if (key == CODED) {

if (keyCode == UP) {

zahl++;

if (zahl > 3) {

zahl = 0;

}

} else if (keyCode == DOWN) {

zahl--;

if(zahl < 0) {

zahl = 3;

}

else if (keyCode == RIGHT) {

rotWert += 10; // Rotwert erhöhen

if (rotWert > 255) { // Begrenzung auf max. 255

rotWert = 255;

}

} else if (keyCode == LEFT) {

rotWert -= 10; // Rotwert verringern

if (rotWert < 0) { // Begrenzung auf min. 0

rotWert = 0;

}

// Text für die Zahl anzeigen

if (zahl == 0) {

text("null", width / 2, height / 2);

} else if (zahl == 1) {

text("eins", width / 2, height / 2);

} else if (zahl == 2) {

text("zwei", width / 2, height / 2);

} else if (zahl == 3) {

text("drei", width / 2, height / 2);

}

}

//Prüfe ob Abstand>20 ist, da sonst Gameover

if (dist(x1, y1, x2, y2)<=diam) { // Aufgabe 1

gameOver = true;

1. dist(x1, y1, x2, y2) berechnet den Abstand zwischen den Mittelpunkten der roten und weißen Kugel.

2. Wenn der Abstand kleiner oder gleich dem Durchmesser der Kugeln (diam) ist, bedeutet das, die Kugeln berühren sich, und das Spiel ist zu Ende (gameOver = true).

if (x1 >= width) {

x1 = x1 - width;

}

if (x1 <= 0) {

x1 = x1 + width;

}

if (y1 >= width) {

y1 = y1 - width;

}

if (y1 <= 0) {

y1 = y1 + width;

}

• Die Bedingungen prüfen, ob die Kugel den Rand des Fensters verlässt.

• Verlässt sie das Fenster nach rechts (x1 >= width), wird ihre Position um die Breite des Fensters nach links verschoben (x1 = x1 - width).

• Ähnliche Anpassungen werden für alle Seiten vorgenommen, wodurch die Kugel wieder auf der gegenüberliegenden Seite erscheint.

float gain = 100 / dist(x1, y1, x2, y2);

Punktestand = Punktestand + gain;

Erklärung:

• Der Abstand zwischen den Kugeln (dist(x1, y1, x2, y2)) wird genutzt, um gain zu berechnen.

• Je kleiner der Abstand (die weiße Kugel ist nah), desto größer ist der Wert von gain.

• Der gain-Wert wird in jeder Iteration von draw() dem Punktestand (Punktestand) hinzugefügt.

void keyPressed() {

xSpeed1 = xSpeed1 * (-1);

ySpeed1 = ySpeed1 * (-1);

}

• Bei jedem Tastendruck (unabhängig von der Taste) wird die Geschwindigkeit in beiden Achsen invertiert: xSpeed1 und ySpeed1 werden jeweils mit -1 multipliziert.

• Dadurch dreht sich die Bewegungsrichtung der roten Kugel um 180°.

x2 = x2 + (x1 - x2) * 0.03;

y2 = y2 + (y1 - y2) * 0.03;

1. Die weiße Kugel bewegt sich bei jeder Iteration ein Stück näher an die Position der roten Kugel heran.

2. (x1 - x2) ist der Abstand in X-Richtung zwischen den beiden Kugeln. Ein Anteil von 3% dieses Abstands (* 0.03) wird zu x2 addiert, wodurch sich die weiße Kugel in Richtung der roten Kugel bewegt.

3. Dasselbe Prinzip gilt für die Y-Richtung.

if (gameOver) {

count++;

if (count == 10) {

count = 0;

red = 255 - red; // Wechsel der Farbe zwischen Rot und Schwarz

}

fill(red, 0, 0);

textSize(60);

textAlign(CENTER);

text("Game Over \n" + (int)Punktestand, 250, 250);

}

• Wenn gameOver wahr ist, werden die Kugeln nicht mehr bewegt. Stattdessen wird der Game Over-Bildschirm gezeichnet.

• Ein Zähler count wird bei jedem Frame um 1 erhöht.

• Wenn count den Wert 10 erreicht, wird der Farbwert red zwischen 255 (Rot) und 0 (Schwarz) gewechselt, wodurch der Text blinkt.

• Der Punktestand (Punktestand) wird als Teil des Textes angezeigt. Die Typumwandlung (int) sorgt dafür, dass keine Nachkommastellen angezeigt werden.

for(int i = 0; i <= 1000000; i++) {

if(i % 29 == 0 && i % 23 == 0 && i % 19 == 0)

println(i);

}

1. Schleife (for-Schleife)

• for (int i = 0; i <= 1000000; i++)

  • Die Schleife startet mit i = 0.

  • Sie erhöht den Wert von i nach jedem Durchlauf um 1 (i++).

  • Sie läuft, solange i <= 1000000 gilt, also von 0 bis 1.000.000.

2. Bedingung (if)

• if (i % 29 == 0 && i % 23 == 0 && i % 19 == 0)

  • Hier wird geprüft, ob die Zahl i durch 29, 23, und 19 gleichzeitig ohne Rest teilbar ist.

  • Der Ausdruck i % 29 == 0 prüft, ob der Rest von i bei der Division durch 29 gleich 0 ist. Das bedeutet, i ist durch 29 teilbar.

  • Diese Prüfung wird mit einer logischen UND-Verknüpfung (&&) kombiniert, sodass alle drei Teilbarkeitsbedingungen erfüllt sein müssen.

3. Ausgabe (println)

• println(i)

  • Wenn i die Bedingung erfüllt (also durch 29, 23, und 19 teilbar ist), wird die Zahl i auf der Konsole ausgegeben.

Äußere Schleife:

java

Code kopieren

for (int a = 1; a <= 9; a++) {

• Die äußere Schleife iteriert über die Ziffer a, die die erste und letzte Ziffer der Zahl bestimmt.

• a läuft von 1 bis 9, da eine Zahl nicht mit 0 beginnen soll.

Innere Schleife:

java

Code kopieren

for (int b = 1; b <= 9; b++) {

• Die innere Schleife iteriert über die Ziffer b, die die zweite und dritte Ziffer der Zahl bestimmt.

• b läuft ebenfalls von 1 bis 9.

Zahlenerstellung und Ausgabe:

java

Code kopieren

println(a + "" + b + "" + b + "" + a);

• Die gespiegelte Zahl wird durch eine Kombination der Werte a und b erstellt:

  • Zuerst a (erste Ziffer),

  • dann b (zweite Ziffer),

  • gefolgt von b (dritte Ziffer),

  • und schließlich a (vierte Ziffer).

• Die Zeichenketten-Verkettung ("" +) sorgt dafür, dass die Zahlen a und b als String interpretiert werden und keine mathematischen Berechnungen (z. B. Addition) stattfinden.

• Beispiel: Wenn a = 1 und b = 2, wird die Zahl 1221 ausgegeben.

1. enstergröße definieren:

   java

   size(500, 500);

   • Mit size(500, 500) wird ein Zeichenfenster mit einer Breite und Höhe von jeweils 500 Pixeln erstellt. Dies ist der Bereich, in dem alle grafischen Operationen stattfinden.

2. Schleife einrichten:

   java

   for(int i = 1; i < 500; i = i+10){

   • Hier wird eine for-Schleife definiert, die bei i=1 startet und so lange läuft, bis i den Wert von 500 erreicht oder überschreitet. i wird in jedem Durchlauf um 10 erhöht (i = i+10). Diese Schleife wird verwendet, um mehrere Linien in regelmäßigen Abständen zu zeichnen.

3. Erste Linie:

   java

   line(i, 0, 500, i);

   • Diese Linie wird von Punkt (i, 0) nach Punkt (500, i) gezeichnet.

   • Der Startpunkt (i, 0) beginnt an der oberen Kante des Fensters, wobei i von links nach rechts verschoben wird.

   • Der Endpunkt (500, i) verschiebt sich entlang der rechten Kante von oben nach unten.

   • In jedem Durchlauf der Schleife wird eine neue Linie gezeichnet, die sich schrittweise nach rechts verschiebt.

4. Zweite Linie:

   java

   line(500, i, 500-i, 500 );

   • Diese Linie verläuft von Punkt (500, i) nach Punkt (500-i, 500).

   • Der Startpunkt (500, i) beginnt an der rechten Kante des Fensters und verschiebt sich von oben nach unten.

   • Der Endpunkt (500-i, 500) beginnt an der unteren Kante und verschiebt sich von rechts nach links.

   • Jede neue Linie in der Schleife beginnt ein Stück weiter unten und endet ein Stück weiter links.

5. Dritte Linie:

   java

   line(500-i, 500, 0, 500-i);

   • Diese Linie wird von Punkt (500-i, 500) nach Punkt (0, 500-i) gezeichnet.

   • Der Startpunkt (500-i, 500) verschiebt sich an der unteren Kante des Fensters von rechts nach links.

   • Der Endpunkt (0, 500-i) bewegt sich an der linken Kante von unten nach oben.

   • Jede neue Linie verschiebt sich weiter nach oben und links.

6. Vierte Linie:

   java

   line(0, 500-i, i, 0);

   • Diese Linie verläuft von Punkt (0, 500-i) nach Punkt (i, 0).

   • Der Startpunkt (0, 500-i) beginnt an der linken Kante des Fensters und verschiebt sich von unten nach oben.

   • Der Endpunkt (i, 0) bewegt sich an der oberen Kante von links nach rechts.

   • Jede neue Linie beginnt ein Stück weiter oben und endet ein Stück weiter rechts.

String str = "Beispiel";

String result;

if (str.length() < 2) {

result = "!";

} else {

char erste = str.charAt(0);

char zweite = str.charAt(str.length() - 1);

result = "" + erste + zweite; // Zeichen zu einer Zeichenkette verketten

}

println(result);

int positiveZahl = 5;

int ziffern = 0;

while (positiveZahl > 0) {

positiveZahl = positiveZahl / 10;

ziffern++;

}

println("Anzahl der Ziffern: " + ziffern);

int zahl1 = 3; // Beispielwert für die erste Zahl

int zahl2 = 5; // Beispielwert für die zweite Zahl

boolean ergebnis = false;

if (zahl1 == 5 || zahl2 == 5) {

ergebnis = true;

} else if (zahl1 + zahl2 == 5) {

ergebnis = true;

} else if (abs(zahl1 - zahl2) == 5) {

ergebnis = true;

} else {

ergebnis = false;

}

println(ergebnis);